diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 7d3e18e26..fda5dcc3c 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -25,9 +25,8 @@ "Rev": "173b8ff953610c13710061e83b95b50c73d7ea50" }, { - "ImportPath": "github.com/howeyc/fsnotify", - "Comment": "v0.9.0-11-g6b1ef89", - "Rev": "6b1ef893dc11e0447abda6da20a5203481878dda" + "ImportPath": "github.com/gizak/termui", + "Rev": "bab8dce01c193d82bc04888a0a9a7814d505f532" }, { "ImportPath": "github.com/huin/goupnp", @@ -50,8 +49,13 @@ "Rev": "fdbe02a1b44e75977b2690062b83cf507d70c013" }, { - "ImportPath": "github.com/obscuren/qml", - "Rev": "c288002b52e905973b131089a8a7c761d4a2c36a" + "ImportPath": "github.com/mattn/go-runewidth", + "Comment": "travisish-33-g5890272", + "Rev": "5890272cd41c5103531cd7b79e428d99c9e97f76" + }, + { + "ImportPath": "github.com/nsf/termbox-go", + "Rev": "675ffd907b7401b8a709a5ef2249978af5616bb2" }, { "ImportPath": "github.com/peterh/liner", @@ -121,14 +125,6 @@ { "ImportPath": "gopkg.in/karalabe/cookiejar.v2/collections/prque", "Rev": "0b2e270613f5d7ba262a5749b9e32270131497a2" - }, - { - "ImportPath": "gopkg.in/qml.v1/cdata", - "Rev": "1116cb9cd8dee23f8d444ded354eb53122739f99" - }, - { - "ImportPath": "gopkg.in/qml.v1/gl/glbase", - "Rev": "1116cb9cd8dee23f8d444ded354eb53122739f99" } ] } diff --git a/Godeps/_workspace/src/github.com/gizak/termui/.gitignore b/Godeps/_workspace/src/github.com/gizak/termui/.gitignore new file mode 100644 index 000000000..daf913b1b --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/.gitignore @@ -0,0 +1,24 @@ +# Compiled Object files, Static and Dynamic libs (Shared Objects) +*.o +*.a +*.so + +# Folders +_obj +_test + +# Architecture specific extensions/prefixes +*.[568vq] +[568vq].out + +*.cgo1.go +*.cgo2.c +_cgo_defun.c +_cgo_gotypes.go +_cgo_export.* + +_testmain.go + +*.exe +*.test +*.prof diff --git a/Godeps/_workspace/src/github.com/gizak/termui/.travis.yml b/Godeps/_workspace/src/github.com/gizak/termui/.travis.yml new file mode 100644 index 000000000..206e88740 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/.travis.yml @@ -0,0 +1,6 @@ +language: go + +go: + - tip + +script: go test -v ./ \ No newline at end of file diff --git a/Godeps/_workspace/src/github.com/gizak/termui/LICENSE b/Godeps/_workspace/src/github.com/gizak/termui/LICENSE new file mode 100644 index 000000000..311ccc74f --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Zack Guo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/Godeps/_workspace/src/github.com/gizak/termui/README.md b/Godeps/_workspace/src/github.com/gizak/termui/README.md new file mode 100644 index 000000000..b9bc3024d --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/README.md @@ -0,0 +1,159 @@ +# termui [![Build Status](https://travis-ci.org/gizak/termui.svg?branch=master)](https://travis-ci.org/gizak/termui) [![Doc Status](https://godoc.org/github.com/gizak/termui?status.png)](https://godoc.org/github.com/gizak/termui) + +## Update 23/06/2015 +Pull requests and master branch are freezing, waiting for merging from `refactoring` branch. + +## Notice +termui comes with ABSOLUTELY NO WARRANTY, and there is a breaking change coming up (see refactoring branch) which will change the `Bufferer` interface and many others. These changes reduce calculation overhead and introduce a new drawing buffer with better capacibilities. We will step into the next stage (call it beta) after merging these changes. + +## Introduction +Go terminal dashboard. Inspired by [blessed-contrib](https://github.com/yaronn/blessed-contrib), but purely in Go. + +Cross-platform, easy to compile, and fully-customizable. + +__Demo:__ (cast under osx 10.10; Terminal.app; Menlo Regular 12pt.) + +demo + +__Grid layout:__ + +Expressive syntax, using [12 columns grid system](http://www.w3schools.com/bootstrap/bootstrap_grid_system.asp) +```go + import ui "github.com/gizak/termui" + // init and create widgets... + + // build + ui.Body.AddRows( + ui.NewRow( + ui.NewCol(6, 0, widget0), + ui.NewCol(6, 0, widget1)), + ui.NewRow( + ui.NewCol(3, 0, widget2), + ui.NewCol(3, 0, widget30, widget31, widget32), + ui.NewCol(6, 0, widget4))) + + // calculate layout + ui.Body.Align() + + ui.Render(ui.Body) +``` +[demo code:](https://github.com/gizak/termui/blob/master/example/grid.go) + +grid + +## Installation + + go get github.com/gizak/termui + +## Usage + +Each component's layout is a bit like HTML block (box model), which has border and padding. + +The `Border` property can be chosen to hide or display (with its border label), when it comes to display, the label takes 1 padding space (i.e. in css: `padding: 1;`, innerHeight and innerWidth therefore shrunk by 1). + +`````go + import ui "github.com/gizak/termui" // <- ui shortcut, optional + + func main() { + err := ui.Init() + if err != nil { + panic(err) + } + defer ui.Close() + + p := ui.NewPar(":PRESS q TO QUIT DEMO") + p.Height = 3 + p.Width = 50 + p.TextFgColor = ui.ColorWhite + p.Border.Label = "Text Box" + p.Border.FgColor = ui.ColorCyan + + g := ui.NewGauge() + g.Percent = 50 + g.Width = 50 + g.Height = 3 + g.Y = 11 + g.Border.Label = "Gauge" + g.BarColor = ui.ColorRed + g.Border.FgColor = ui.ColorWhite + g.Border.LabelFgColor = ui.ColorCyan + + ui.Render(p, g) + + // event handler... + } +````` + +Note that components can be overlapped (I'd rather call this a feature...), `Render(rs ...Renderer)` renders its args from left to right (i.e. each component's weight is arising from left to right). + +## Themes + +_All_ colors in _all_ components can be changed at _any_ time, while there provides some predefined color schemes: + +```go +// for now there are only two themes: default and helloworld +termui.UseTheme("helloworld") + +// create components... +``` +The `default ` theme's settings depend on the user's terminal color scheme, which is saying if your terminal default font color is white and background is white, it will be like: + +default + +The `helloworld` color scheme drops in some colors! + +helloworld + +## Widgets + +#### Par + +[demo code](https://github.com/gizak/termui/blob/master/example/par.go) + +par + +#### List +[demo code](https://github.com/gizak/termui/blob/master/example/list.go) + +list + +#### Gauge +[demo code](https://github.com/gizak/termui/blob/master/example/gauge.go) + +gauge + +#### Line Chart +[demo code](https://github.com/gizak/termui/blob/master/example/linechart.go) + +linechart + +#### Bar Chart +[demo code](https://github.com/gizak/termui/blob/master/example/barchart.go) + +barchart + +#### Mult-Bar / Stacked-Bar Chart +[demo code](https://github.com/gizak/termui/blob/master/example/mbarchart.go) + +barchart + +#### Sparklines +[demo code](https://github.com/gizak/termui/blob/master/example/sparklines.go) + +sparklines + + +## GoDoc + +[godoc](https://godoc.org/github.com/gizak/termui) + +## TODO + +- [x] Grid layout +- [ ] Event system +- [ ] Canvas widget +- [ ] Refine APIs +- [ ] Focusable widgets + +## License +This library is under the [MIT License](http://opensource.org/licenses/MIT) diff --git a/Godeps/_workspace/src/github.com/gizak/termui/bar.go b/Godeps/_workspace/src/github.com/gizak/termui/bar.go new file mode 100644 index 000000000..57bae0ae8 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/bar.go @@ -0,0 +1,135 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import "fmt" + +// BarChart creates multiple bars in a widget: +/* + bc := termui.NewBarChart() + data := []int{3, 2, 5, 3, 9, 5} + bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} + bc.Border.Label = "Bar Chart" + bc.Data = data + bc.Width = 26 + bc.Height = 10 + bc.DataLabels = bclabels + bc.TextColor = termui.ColorGreen + bc.BarColor = termui.ColorRed + bc.NumColor = termui.ColorYellow +*/ +type BarChart struct { + Block + BarColor Attribute + TextColor Attribute + NumColor Attribute + Data []int + DataLabels []string + BarWidth int + BarGap int + labels [][]rune + dataNum [][]rune + numBar int + scale float64 + max int +} + +// NewBarChart returns a new *BarChart with current theme. +func NewBarChart() *BarChart { + bc := &BarChart{Block: *NewBlock()} + bc.BarColor = theme.BarChartBar + bc.NumColor = theme.BarChartNum + bc.TextColor = theme.BarChartText + bc.BarGap = 1 + bc.BarWidth = 3 + return bc +} + +func (bc *BarChart) layout() { + bc.numBar = bc.innerWidth / (bc.BarGap + bc.BarWidth) + bc.labels = make([][]rune, bc.numBar) + bc.dataNum = make([][]rune, len(bc.Data)) + + for i := 0; i < bc.numBar && i < len(bc.DataLabels) && i < len(bc.Data); i++ { + bc.labels[i] = trimStr2Runes(bc.DataLabels[i], bc.BarWidth) + n := bc.Data[i] + s := fmt.Sprint(n) + bc.dataNum[i] = trimStr2Runes(s, bc.BarWidth) + } + + //bc.max = bc.Data[0] // what if Data is nil? Sometimes when bar graph is nill it produces panic with panic: runtime error: index out of range + // Asign a negative value to get maxvalue auto-populates + if bc.max == 0 { + bc.max = -1 + } + for i := 0; i < len(bc.Data); i++ { + if bc.max < bc.Data[i] { + bc.max = bc.Data[i] + } + } + bc.scale = float64(bc.max) / float64(bc.innerHeight-1) +} + +func (bc *BarChart) SetMax(max int) { + + if max > 0 { + bc.max = max + } +} + +// Buffer implements Bufferer interface. +func (bc *BarChart) Buffer() []Point { + ps := bc.Block.Buffer() + bc.layout() + + for i := 0; i < bc.numBar && i < len(bc.Data) && i < len(bc.DataLabels); i++ { + h := int(float64(bc.Data[i]) / bc.scale) + oftX := i * (bc.BarWidth + bc.BarGap) + // plot bar + for j := 0; j < bc.BarWidth; j++ { + for k := 0; k < h; k++ { + p := Point{} + p.Ch = ' ' + p.Bg = bc.BarColor + if bc.BarColor == ColorDefault { // when color is default, space char treated as transparent! + p.Bg |= AttrReverse + } + p.X = bc.innerX + i*(bc.BarWidth+bc.BarGap) + j + p.Y = bc.innerY + bc.innerHeight - 2 - k + ps = append(ps, p) + } + } + // plot text + for j, k := 0, 0; j < len(bc.labels[i]); j++ { + w := charWidth(bc.labels[i][j]) + p := Point{} + p.Ch = bc.labels[i][j] + p.Bg = bc.BgColor + p.Fg = bc.TextColor + p.Y = bc.innerY + bc.innerHeight - 1 + p.X = bc.innerX + oftX + k + ps = append(ps, p) + k += w + } + // plot num + for j := 0; j < len(bc.dataNum[i]); j++ { + p := Point{} + p.Ch = bc.dataNum[i][j] + p.Fg = bc.NumColor + p.Bg = bc.BarColor + if bc.BarColor == ColorDefault { // the same as above + p.Bg |= AttrReverse + } + if h == 0 { + p.Bg = bc.BgColor + } + p.X = bc.innerX + oftX + (bc.BarWidth-len(bc.dataNum[i]))/2 + j + p.Y = bc.innerY + bc.innerHeight - 2 + ps = append(ps, p) + } + } + + return bc.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/block.go b/Godeps/_workspace/src/github.com/gizak/termui/block.go new file mode 100644 index 000000000..953136596 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/block.go @@ -0,0 +1,142 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +// Block is a base struct for all other upper level widgets, +// consider it as css: display:block. +// Normally you do not need to create it manually. +type Block struct { + X int + Y int + Border labeledBorder + IsDisplay bool + HasBorder bool + BgColor Attribute + Width int + Height int + innerWidth int + innerHeight int + innerX int + innerY int + PaddingTop int + PaddingBottom int + PaddingLeft int + PaddingRight int +} + +// NewBlock returns a *Block which inherits styles from current theme. +func NewBlock() *Block { + d := Block{} + d.IsDisplay = true + d.HasBorder = theme.HasBorder + d.Border.BgColor = theme.BorderBg + d.Border.FgColor = theme.BorderFg + d.Border.LabelBgColor = theme.BorderLabelTextBg + d.Border.LabelFgColor = theme.BorderLabelTextFg + d.BgColor = theme.BlockBg + d.Width = 2 + d.Height = 2 + return &d +} + +// compute box model +func (d *Block) align() { + d.innerWidth = d.Width - d.PaddingLeft - d.PaddingRight + d.innerHeight = d.Height - d.PaddingTop - d.PaddingBottom + d.innerX = d.X + d.PaddingLeft + d.innerY = d.Y + d.PaddingTop + + if d.HasBorder { + d.innerHeight -= 2 + d.innerWidth -= 2 + d.Border.X = d.X + d.Border.Y = d.Y + d.Border.Width = d.Width + d.Border.Height = d.Height + d.innerX++ + d.innerY++ + } + + if d.innerHeight < 0 { + d.innerHeight = 0 + } + if d.innerWidth < 0 { + d.innerWidth = 0 + } + +} + +// InnerBounds returns the internal bounds of the block after aligning and +// calculating the padding and border, if any. +func (d *Block) InnerBounds() (x, y, width, height int) { + d.align() + return d.innerX, d.innerY, d.innerWidth, d.innerHeight +} + +// Buffer implements Bufferer interface. +// Draw background and border (if any). +func (d *Block) Buffer() []Point { + d.align() + + ps := []Point{} + if !d.IsDisplay { + return ps + } + + if d.HasBorder { + ps = d.Border.Buffer() + } + + for i := 0; i < d.innerWidth; i++ { + for j := 0; j < d.innerHeight; j++ { + p := Point{} + p.X = d.X + 1 + i + p.Y = d.Y + 1 + j + p.Ch = ' ' + p.Bg = d.BgColor + ps = append(ps, p) + } + } + return ps +} + +// GetHeight implements GridBufferer. +// It returns current height of the block. +func (d Block) GetHeight() int { + return d.Height +} + +// SetX implements GridBufferer interface, which sets block's x position. +func (d *Block) SetX(x int) { + d.X = x +} + +// SetY implements GridBufferer interface, it sets y position for block. +func (d *Block) SetY(y int) { + d.Y = y +} + +// SetWidth implements GridBuffer interface, it sets block's width. +func (d *Block) SetWidth(w int) { + d.Width = w +} + +// chop the overflow parts +func (d *Block) chopOverflow(ps []Point) []Point { + nps := make([]Point, 0, len(ps)) + x := d.X + y := d.Y + w := d.Width + h := d.Height + for _, v := range ps { + if v.X >= x && + v.X < x+w && + v.Y >= y && + v.Y < y+h { + nps = append(nps, v) + } + } + return nps +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/block_test.go b/Godeps/_workspace/src/github.com/gizak/termui/block_test.go new file mode 100644 index 000000000..2de205b21 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/block_test.go @@ -0,0 +1,46 @@ +package termui + +import "testing" + +func TestBlock_InnerBounds(t *testing.T) { + b := NewBlock() + b.X = 10 + b.Y = 11 + b.Width = 12 + b.Height = 13 + + assert := func(name string, x, y, w, h int) { + t.Log(name) + cx, cy, cw, ch := b.InnerBounds() + if cx != x { + t.Errorf("expected x to be %d but got %d", x, cx) + } + if cy != y { + t.Errorf("expected y to be %d but got %d", y, cy) + } + if cw != w { + t.Errorf("expected width to be %d but got %d", w, cw) + } + if ch != h { + t.Errorf("expected height to be %d but got %d", h, ch) + } + } + + b.HasBorder = false + assert("no border, no padding", 10, 11, 12, 13) + + b.HasBorder = true + assert("border, no padding", 11, 12, 10, 11) + + b.PaddingBottom = 2 + assert("border, 2b padding", 11, 12, 10, 9) + + b.PaddingTop = 3 + assert("border, 2b 3t padding", 11, 15, 10, 6) + + b.PaddingLeft = 4 + assert("border, 2b 3t 4l padding", 15, 15, 6, 6) + + b.PaddingRight = 5 + assert("border, 2b 3t 4l 5r padding", 15, 15, 1, 6) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/box.go b/Godeps/_workspace/src/github.com/gizak/termui/box.go new file mode 100644 index 000000000..1dcfd8692 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/box.go @@ -0,0 +1,117 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +type border struct { + X int + Y int + Width int + Height int + FgColor Attribute + BgColor Attribute +} + +type hline struct { + X int + Y int + Length int + FgColor Attribute + BgColor Attribute +} + +type vline struct { + X int + Y int + Length int + FgColor Attribute + BgColor Attribute +} + +// Draw a horizontal line. +func (l hline) Buffer() []Point { + pts := make([]Point, l.Length) + for i := 0; i < l.Length; i++ { + pts[i].X = l.X + i + pts[i].Y = l.Y + pts[i].Ch = HORIZONTAL_LINE + pts[i].Bg = l.BgColor + pts[i].Fg = l.FgColor + } + return pts +} + +// Draw a vertical line. +func (l vline) Buffer() []Point { + pts := make([]Point, l.Length) + for i := 0; i < l.Length; i++ { + pts[i].X = l.X + pts[i].Y = l.Y + i + pts[i].Ch = VERTICAL_LINE + pts[i].Bg = l.BgColor + pts[i].Fg = l.FgColor + } + return pts +} + +// Draw a box border. +func (b border) Buffer() []Point { + if b.Width < 2 || b.Height < 2 { + return nil + } + pts := make([]Point, 2*b.Width+2*b.Height-4) + + pts[0].X = b.X + pts[0].Y = b.Y + pts[0].Fg = b.FgColor + pts[0].Bg = b.BgColor + pts[0].Ch = TOP_LEFT + + pts[1].X = b.X + b.Width - 1 + pts[1].Y = b.Y + pts[1].Fg = b.FgColor + pts[1].Bg = b.BgColor + pts[1].Ch = TOP_RIGHT + + pts[2].X = b.X + pts[2].Y = b.Y + b.Height - 1 + pts[2].Fg = b.FgColor + pts[2].Bg = b.BgColor + pts[2].Ch = BOTTOM_LEFT + + pts[3].X = b.X + b.Width - 1 + pts[3].Y = b.Y + b.Height - 1 + pts[3].Fg = b.FgColor + pts[3].Bg = b.BgColor + pts[3].Ch = BOTTOM_RIGHT + + copy(pts[4:], (hline{b.X + 1, b.Y, b.Width - 2, b.FgColor, b.BgColor}).Buffer()) + copy(pts[4+b.Width-2:], (hline{b.X + 1, b.Y + b.Height - 1, b.Width - 2, b.FgColor, b.BgColor}).Buffer()) + copy(pts[4+2*b.Width-4:], (vline{b.X, b.Y + 1, b.Height - 2, b.FgColor, b.BgColor}).Buffer()) + copy(pts[4+2*b.Width-4+b.Height-2:], (vline{b.X + b.Width - 1, b.Y + 1, b.Height - 2, b.FgColor, b.BgColor}).Buffer()) + + return pts +} + +type labeledBorder struct { + border + Label string + LabelFgColor Attribute + LabelBgColor Attribute +} + +// Draw a box border with label. +func (lb labeledBorder) Buffer() []Point { + ps := lb.border.Buffer() + maxTxtW := lb.Width - 2 + rs := trimStr2Runes(lb.Label, maxTxtW) + + for i, j, w := 0, 0, 0; i < len(rs); i++ { + w = charWidth(rs[i]) + ps = append(ps, newPointWithAttrs(rs[i], lb.X+1+j, lb.Y, lb.LabelFgColor, lb.LabelBgColor)) + j += w + } + + return ps +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/box_others.go b/Godeps/_workspace/src/github.com/gizak/termui/box_others.go new file mode 100644 index 000000000..bcc3d7ded --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/box_others.go @@ -0,0 +1,14 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build !windows + +package termui + +const TOP_RIGHT = '┐' +const VERTICAL_LINE = '│' +const HORIZONTAL_LINE = '─' +const TOP_LEFT = '┌' +const BOTTOM_RIGHT = '┘' +const BOTTOM_LEFT = '└' diff --git a/Godeps/_workspace/src/github.com/gizak/termui/box_windows.go b/Godeps/_workspace/src/github.com/gizak/termui/box_windows.go new file mode 100644 index 000000000..dd39019fe --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/box_windows.go @@ -0,0 +1,14 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build windows + +package termui + +const TOP_RIGHT = '+' +const VERTICAL_LINE = '|' +const HORIZONTAL_LINE = '-' +const TOP_LEFT = '+' +const BOTTOM_RIGHT = '+' +const BOTTOM_LEFT = '+' diff --git a/Godeps/_workspace/src/github.com/gizak/termui/canvas.go b/Godeps/_workspace/src/github.com/gizak/termui/canvas.go new file mode 100644 index 000000000..614635ee4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/canvas.go @@ -0,0 +1,74 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +/* +dots: + ,___, + |1 4| + |2 5| + |3 6| + |7 8| + ````` +*/ + +var brailleBase = '\u2800' + +var brailleOftMap = [4][2]rune{ + {'\u0001', '\u0008'}, + {'\u0002', '\u0010'}, + {'\u0004', '\u0020'}, + {'\u0040', '\u0080'}} + +// Canvas contains drawing map: i,j -> rune +type Canvas map[[2]int]rune + +// NewCanvas returns an empty Canvas +func NewCanvas() Canvas { + return make(map[[2]int]rune) +} + +func chOft(x, y int) rune { + return brailleOftMap[y%4][x%2] +} + +func (c Canvas) rawCh(x, y int) rune { + if ch, ok := c[[2]int{x, y}]; ok { + return ch + } + return '\u0000' //brailleOffset +} + +// return coordinate in terminal +func chPos(x, y int) (int, int) { + return y / 4, x / 2 +} + +// Set sets a point (x,y) in the virtual coordinate +func (c Canvas) Set(x, y int) { + i, j := chPos(x, y) + ch := c.rawCh(i, j) + ch |= chOft(x, y) + c[[2]int{i, j}] = ch +} + +// Unset removes point (x,y) +func (c Canvas) Unset(x, y int) { + i, j := chPos(x, y) + ch := c.rawCh(i, j) + ch &= ^chOft(x, y) + c[[2]int{i, j}] = ch +} + +// Buffer returns un-styled points +func (c Canvas) Buffer() []Point { + ps := make([]Point, len(c)) + i := 0 + for k, v := range c { + ps[i] = newPoint(v+brailleBase, k[0], k[1]) + i++ + } + return ps +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/canvas_test.go b/Godeps/_workspace/src/github.com/gizak/termui/canvas_test.go new file mode 100644 index 000000000..021949ced --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/canvas_test.go @@ -0,0 +1,55 @@ +package termui + +import ( + "testing" + + "github.com/davecgh/go-spew/spew" +) + +func TestCanvasSet(t *testing.T) { + c := NewCanvas() + c.Set(0, 0) + c.Set(0, 1) + c.Set(0, 2) + c.Set(0, 3) + c.Set(1, 3) + c.Set(2, 3) + c.Set(3, 3) + c.Set(4, 3) + c.Set(5, 3) + spew.Dump(c) +} + +func TestCanvasUnset(t *testing.T) { + c := NewCanvas() + c.Set(0, 0) + c.Set(0, 1) + c.Set(0, 2) + c.Unset(0, 2) + spew.Dump(c) + c.Unset(0, 3) + spew.Dump(c) +} + +func TestCanvasBuffer(t *testing.T) { + c := NewCanvas() + c.Set(0, 0) + c.Set(0, 1) + c.Set(0, 2) + c.Set(0, 3) + c.Set(1, 3) + c.Set(2, 3) + c.Set(3, 3) + c.Set(4, 3) + c.Set(5, 3) + c.Set(6, 3) + c.Set(7, 2) + c.Set(8, 1) + c.Set(9, 0) + bufs := c.Buffer() + rs := make([]rune, len(bufs)) + for i, v := range bufs { + rs[i] = v.Ch + } + spew.Dump(string(rs)) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/chart.go b/Godeps/_workspace/src/github.com/gizak/termui/chart.go new file mode 100644 index 000000000..d6fb8bc7d --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/chart.go @@ -0,0 +1,336 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import ( + "fmt" + "math" +) + +// only 16 possible combinations, why bother +var braillePatterns = map[[2]int]rune{ + [2]int{0, 0}: '⣀', + [2]int{0, 1}: '⡠', + [2]int{0, 2}: '⡐', + [2]int{0, 3}: '⡈', + + [2]int{1, 0}: '⢄', + [2]int{1, 1}: '⠤', + [2]int{1, 2}: '⠔', + [2]int{1, 3}: '⠌', + + [2]int{2, 0}: '⢂', + [2]int{2, 1}: '⠢', + [2]int{2, 2}: '⠒', + [2]int{2, 3}: '⠊', + + [2]int{3, 0}: '⢁', + [2]int{3, 1}: '⠡', + [2]int{3, 2}: '⠑', + [2]int{3, 3}: '⠉', +} + +var lSingleBraille = [4]rune{'\u2840', '⠄', '⠂', '⠁'} +var rSingleBraille = [4]rune{'\u2880', '⠠', '⠐', '⠈'} + +// LineChart has two modes: braille(default) and dot. Using braille gives 2x capicity as dot mode, +// because one braille char can represent two data points. +/* + lc := termui.NewLineChart() + lc.Border.Label = "braille-mode Line Chart" + lc.Data = [1.2, 1.3, 1.5, 1.7, 1.5, 1.6, 1.8, 2.0] + lc.Width = 50 + lc.Height = 12 + lc.AxesColor = termui.ColorWhite + lc.LineColor = termui.ColorGreen | termui.AttrBold + // termui.Render(lc)... +*/ +type LineChart struct { + Block + Data []float64 + DataLabels []string // if unset, the data indices will be used + Mode string // braille | dot + DotStyle rune + LineColor Attribute + scale float64 // data span per cell on y-axis + AxesColor Attribute + drawingX int + drawingY int + axisYHeight int + axisXWidth int + axisYLebelGap int + axisXLebelGap int + topValue float64 + bottomValue float64 + labelX [][]rune + labelY [][]rune + labelYSpace int + maxY float64 + minY float64 +} + +// NewLineChart returns a new LineChart with current theme. +func NewLineChart() *LineChart { + lc := &LineChart{Block: *NewBlock()} + lc.AxesColor = theme.LineChartAxes + lc.LineColor = theme.LineChartLine + lc.Mode = "braille" + lc.DotStyle = '•' + lc.axisXLebelGap = 2 + lc.axisYLebelGap = 1 + lc.bottomValue = math.Inf(1) + lc.topValue = math.Inf(-1) + return lc +} + +// one cell contains two data points +// so the capicity is 2x as dot-mode +func (lc *LineChart) renderBraille() []Point { + ps := []Point{} + + // return: b -> which cell should the point be in + // m -> in the cell, divided into 4 equal height levels, which subcell? + getPos := func(d float64) (b, m int) { + cnt4 := int((d-lc.bottomValue)/(lc.scale/4) + 0.5) + b = cnt4 / 4 + m = cnt4 % 4 + return + } + // plot points + for i := 0; 2*i+1 < len(lc.Data) && i < lc.axisXWidth; i++ { + b0, m0 := getPos(lc.Data[2*i]) + b1, m1 := getPos(lc.Data[2*i+1]) + + if b0 == b1 { + p := Point{} + p.Ch = braillePatterns[[2]int{m0, m1}] + p.Bg = lc.BgColor + p.Fg = lc.LineColor + p.Y = lc.innerY + lc.innerHeight - 3 - b0 + p.X = lc.innerX + lc.labelYSpace + 1 + i + ps = append(ps, p) + } else { + p0 := newPointWithAttrs(lSingleBraille[m0], + lc.innerX+lc.labelYSpace+1+i, + lc.innerY+lc.innerHeight-3-b0, + lc.LineColor, + lc.BgColor) + p1 := newPointWithAttrs(rSingleBraille[m1], + lc.innerX+lc.labelYSpace+1+i, + lc.innerY+lc.innerHeight-3-b1, + lc.LineColor, + lc.BgColor) + ps = append(ps, p0, p1) + } + + } + return ps +} + +func (lc *LineChart) renderDot() []Point { + ps := []Point{} + for i := 0; i < len(lc.Data) && i < lc.axisXWidth; i++ { + p := Point{} + p.Ch = lc.DotStyle + p.Fg = lc.LineColor + p.Bg = lc.BgColor + p.X = lc.innerX + lc.labelYSpace + 1 + i + p.Y = lc.innerY + lc.innerHeight - 3 - int((lc.Data[i]-lc.bottomValue)/lc.scale+0.5) + ps = append(ps, p) + } + + return ps +} + +func (lc *LineChart) calcLabelX() { + lc.labelX = [][]rune{} + + for i, l := 0, 0; i < len(lc.DataLabels) && l < lc.axisXWidth; i++ { + if lc.Mode == "dot" { + if l >= len(lc.DataLabels) { + break + } + + s := str2runes(lc.DataLabels[l]) + w := strWidth(lc.DataLabels[l]) + if l+w <= lc.axisXWidth { + lc.labelX = append(lc.labelX, s) + } + l += w + lc.axisXLebelGap + } else { // braille + if 2*l >= len(lc.DataLabels) { + break + } + + s := str2runes(lc.DataLabels[2*l]) + w := strWidth(lc.DataLabels[2*l]) + if l+w <= lc.axisXWidth { + lc.labelX = append(lc.labelX, s) + } + l += w + lc.axisXLebelGap + + } + } +} + +func shortenFloatVal(x float64) string { + s := fmt.Sprintf("%.2f", x) + if len(s)-3 > 3 { + s = fmt.Sprintf("%.2e", x) + } + + if x < 0 { + s = fmt.Sprintf("%.2f", x) + } + return s +} + +func (lc *LineChart) calcLabelY() { + span := lc.topValue - lc.bottomValue + lc.scale = span / float64(lc.axisYHeight) + + n := (1 + lc.axisYHeight) / (lc.axisYLebelGap + 1) + lc.labelY = make([][]rune, n) + maxLen := 0 + for i := 0; i < n; i++ { + s := str2runes(shortenFloatVal(lc.bottomValue + float64(i)*span/float64(n))) + if len(s) > maxLen { + maxLen = len(s) + } + lc.labelY[i] = s + } + + lc.labelYSpace = maxLen +} + +func (lc *LineChart) calcLayout() { + // set datalabels if it is not provided + if lc.DataLabels == nil || len(lc.DataLabels) == 0 { + lc.DataLabels = make([]string, len(lc.Data)) + for i := range lc.Data { + lc.DataLabels[i] = fmt.Sprint(i) + } + } + + // lazy increase, to avoid y shaking frequently + // update bound Y when drawing is gonna overflow + lc.minY = lc.Data[0] + lc.maxY = lc.Data[0] + + // valid visible range + vrange := lc.innerWidth + if lc.Mode == "braille" { + vrange = 2 * lc.innerWidth + } + if vrange > len(lc.Data) { + vrange = len(lc.Data) + } + + for _, v := range lc.Data[:vrange] { + if v > lc.maxY { + lc.maxY = v + } + if v < lc.minY { + lc.minY = v + } + } + + span := lc.maxY - lc.minY + + if lc.minY < lc.bottomValue { + lc.bottomValue = lc.minY - 0.2*span + } + + if lc.maxY > lc.topValue { + lc.topValue = lc.maxY + 0.2*span + } + + lc.axisYHeight = lc.innerHeight - 2 + lc.calcLabelY() + + lc.axisXWidth = lc.innerWidth - 1 - lc.labelYSpace + lc.calcLabelX() + + lc.drawingX = lc.innerX + 1 + lc.labelYSpace + lc.drawingY = lc.innerY +} + +func (lc *LineChart) plotAxes() []Point { + origY := lc.innerY + lc.innerHeight - 2 + origX := lc.innerX + lc.labelYSpace + + ps := []Point{newPointWithAttrs(ORIGIN, origX, origY, lc.AxesColor, lc.BgColor)} + + for x := origX + 1; x < origX+lc.axisXWidth; x++ { + p := Point{} + p.X = x + p.Y = origY + p.Bg = lc.BgColor + p.Fg = lc.AxesColor + p.Ch = HDASH + ps = append(ps, p) + } + + for dy := 1; dy <= lc.axisYHeight; dy++ { + p := Point{} + p.X = origX + p.Y = origY - dy + p.Bg = lc.BgColor + p.Fg = lc.AxesColor + p.Ch = VDASH + ps = append(ps, p) + } + + // x label + oft := 0 + for _, rs := range lc.labelX { + if oft+len(rs) > lc.axisXWidth { + break + } + for j, r := range rs { + p := Point{} + p.Ch = r + p.Fg = lc.AxesColor + p.Bg = lc.BgColor + p.X = origX + oft + j + p.Y = lc.innerY + lc.innerHeight - 1 + ps = append(ps, p) + } + oft += len(rs) + lc.axisXLebelGap + } + + // y labels + for i, rs := range lc.labelY { + for j, r := range rs { + p := Point{} + p.Ch = r + p.Fg = lc.AxesColor + p.Bg = lc.BgColor + p.X = lc.innerX + j + p.Y = origY - i*(lc.axisYLebelGap+1) + ps = append(ps, p) + } + } + + return ps +} + +// Buffer implements Bufferer interface. +func (lc *LineChart) Buffer() []Point { + ps := lc.Block.Buffer() + if lc.Data == nil || len(lc.Data) == 0 { + return ps + } + lc.calcLayout() + ps = append(ps, lc.plotAxes()...) + + if lc.Mode == "dot" { + ps = append(ps, lc.renderDot()...) + } else { + ps = append(ps, lc.renderBraille()...) + } + + return lc.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/chart_others.go b/Godeps/_workspace/src/github.com/gizak/termui/chart_others.go new file mode 100644 index 000000000..8911873b6 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/chart_others.go @@ -0,0 +1,11 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build !windows + +package termui + +const VDASH = '┊' +const HDASH = '┈' +const ORIGIN = '└' diff --git a/Godeps/_workspace/src/github.com/gizak/termui/chart_windows.go b/Godeps/_workspace/src/github.com/gizak/termui/chart_windows.go new file mode 100644 index 000000000..9f9a5e96c --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/chart_windows.go @@ -0,0 +1,11 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build windows + +package termui + +const VDASH = '|' +const HDASH = '-' +const ORIGIN = '+' diff --git a/Godeps/_workspace/src/github.com/gizak/termui/doc.go b/Godeps/_workspace/src/github.com/gizak/termui/doc.go new file mode 100644 index 000000000..43f886f55 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/doc.go @@ -0,0 +1,27 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +/* +Package termui is a library designed for creating command line UI. For more info, goto http://github.com/gizak/termui + +A simplest example: + package main + + import ui "github.com/gizak/termui" + + func main() { + if err:=ui.Init(); err != nil { + panic(err) + } + defer ui.Close() + + g := ui.NewGauge() + g.Percent = 50 + g.Width = 50 + g.Border.Label = "Gauge" + + ui.Render(g) + } +*/ +package termui diff --git a/Godeps/_workspace/src/github.com/gizak/termui/events.go b/Godeps/_workspace/src/github.com/gizak/termui/events.go new file mode 100644 index 000000000..23a189b56 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/events.go @@ -0,0 +1,219 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. +// +// Portions of this file uses [termbox-go](https://github.com/nsf/termbox-go/blob/54b74d087b7c397c402d0e3b66d2ccb6eaf5c2b4/api_common.go) +// by [authors](https://github.com/nsf/termbox-go/blob/master/AUTHORS) +// under [license](https://github.com/nsf/termbox-go/blob/master/LICENSE) + +package termui + +import "github.com/nsf/termbox-go" + +/***********************************termbox-go**************************************/ + +type ( + EventType uint8 + Modifier uint8 + Key uint16 +) + +// This type represents a termbox event. The 'Mod', 'Key' and 'Ch' fields are +// valid if 'Type' is EventKey. The 'Width' and 'Height' fields are valid if +// 'Type' is EventResize. The 'Err' field is valid if 'Type' is EventError. +type Event struct { + Type EventType // one of Event* constants + Mod Modifier // one of Mod* constants or 0 + Key Key // one of Key* constants, invalid if 'Ch' is not 0 + Ch rune // a unicode character + Width int // width of the screen + Height int // height of the screen + Err error // error in case if input failed + MouseX int // x coord of mouse + MouseY int // y coord of mouse + N int // number of bytes written when getting a raw event +} + +const ( + KeyF1 Key = 0xFFFF - iota + KeyF2 + KeyF3 + KeyF4 + KeyF5 + KeyF6 + KeyF7 + KeyF8 + KeyF9 + KeyF10 + KeyF11 + KeyF12 + KeyInsert + KeyDelete + KeyHome + KeyEnd + KeyPgup + KeyPgdn + KeyArrowUp + KeyArrowDown + KeyArrowLeft + KeyArrowRight + key_min // see terminfo + MouseLeft + MouseMiddle + MouseRight +) + +const ( + KeyCtrlTilde Key = 0x00 + KeyCtrl2 Key = 0x00 + KeyCtrlSpace Key = 0x00 + KeyCtrlA Key = 0x01 + KeyCtrlB Key = 0x02 + KeyCtrlC Key = 0x03 + KeyCtrlD Key = 0x04 + KeyCtrlE Key = 0x05 + KeyCtrlF Key = 0x06 + KeyCtrlG Key = 0x07 + KeyBackspace Key = 0x08 + KeyCtrlH Key = 0x08 + KeyTab Key = 0x09 + KeyCtrlI Key = 0x09 + KeyCtrlJ Key = 0x0A + KeyCtrlK Key = 0x0B + KeyCtrlL Key = 0x0C + KeyEnter Key = 0x0D + KeyCtrlM Key = 0x0D + KeyCtrlN Key = 0x0E + KeyCtrlO Key = 0x0F + KeyCtrlP Key = 0x10 + KeyCtrlQ Key = 0x11 + KeyCtrlR Key = 0x12 + KeyCtrlS Key = 0x13 + KeyCtrlT Key = 0x14 + KeyCtrlU Key = 0x15 + KeyCtrlV Key = 0x16 + KeyCtrlW Key = 0x17 + KeyCtrlX Key = 0x18 + KeyCtrlY Key = 0x19 + KeyCtrlZ Key = 0x1A + KeyEsc Key = 0x1B + KeyCtrlLsqBracket Key = 0x1B + KeyCtrl3 Key = 0x1B + KeyCtrl4 Key = 0x1C + KeyCtrlBackslash Key = 0x1C + KeyCtrl5 Key = 0x1D + KeyCtrlRsqBracket Key = 0x1D + KeyCtrl6 Key = 0x1E + KeyCtrl7 Key = 0x1F + KeyCtrlSlash Key = 0x1F + KeyCtrlUnderscore Key = 0x1F + KeySpace Key = 0x20 + KeyBackspace2 Key = 0x7F + KeyCtrl8 Key = 0x7F +) + +// Alt modifier constant, see Event.Mod field and SetInputMode function. +const ( + ModAlt Modifier = 0x01 +) + +// Event type. See Event.Type field. +const ( + EventKey EventType = iota + EventResize + EventMouse + EventError + EventInterrupt + EventRaw + EventNone +) + +/**************************************end**************************************/ + +// convert termbox.Event to termui.Event +func uiEvt(e termbox.Event) Event { + event := Event{} + event.Type = EventType(e.Type) + event.Mod = Modifier(e.Mod) + event.Key = Key(e.Key) + event.Ch = e.Ch + event.Width = e.Width + event.Height = e.Height + event.Err = e.Err + event.MouseX = e.MouseX + event.MouseY = e.MouseY + event.N = e.N + + return event +} + +var evtChs = make([]chan Event, 0) + +// EventCh returns an output-only event channel. +// This function can be called many times (multiplexer). +func EventCh() <-chan Event { + out := make(chan Event) + evtChs = append(evtChs, out) + return out +} + +// turn on event listener +func evtListen() { + go func() { + for { + e := termbox.PollEvent() + // dispatch + for _, c := range evtChs { + go func(ch chan Event) { + ch <- uiEvt(e) + }(c) + } + } + }() +} + +/* +// EventHandlers is a handler sequence +var EventHandlers []func(Event) + +var signalQuit = make(chan bool) + +// Quit sends quit signal to terminate termui +func Quit() { + signalQuit <- true +} + +// Wait listening to signalQuit, block operation. +func Wait() { + <-signalQuit +} + +// RegEvtHandler register function into TSEventHandler sequence. +func RegEvtHandler(fn func(Event)) { + EventHandlers = append(EventHandlers, fn) +} + +// EventLoop handles all events and +// redirects every event to callbacks in EventHandlers +func EventLoop() { + evt := make(chan termbox.Event) + + go func() { + for { + evt <- termbox.PollEvent() + } + }() + + for { + select { + case c := <-signalQuit: + defer func() { signalQuit <- c }() + return + case e := <-evt: + for _, fn := range EventHandlers { + fn(uiEvt(e)) + } + } + } +} +*/ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/events_test.go b/Godeps/_workspace/src/github.com/gizak/termui/events_test.go new file mode 100644 index 000000000..1137b1d26 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/events_test.go @@ -0,0 +1,28 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. +// +// Portions of this file uses [termbox-go](https://github.com/nsf/termbox-go/blob/54b74d087b7c397c402d0e3b66d2ccb6eaf5c2b4/api_common.go) +// by [authors](https://github.com/nsf/termbox-go/blob/master/AUTHORS) +// under [license](https://github.com/nsf/termbox-go/blob/master/LICENSE) + +package termui + +import ( + "errors" + "testing" + + termbox "github.com/nsf/termbox-go" + "github.com/stretchr/testify/assert" +) + +type boxEvent termbox.Event + +func TestUiEvt(t *testing.T) { + err := errors.New("This is a mock error") + event := boxEvent{3, 5, 2, 'H', 200, 500, err, 50, 30, 2} + expetced := Event{3, 5, 2, 'H', 200, 500, err, 50, 30, 2} + + // We need to do that ugly casting so that vet does not complain + assert.Equal(t, uiEvt(termbox.Event(event)), expetced) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/barchart.go b/Godeps/_workspace/src/github.com/gizak/termui/example/barchart.go new file mode 100644 index 000000000..83947f580 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/barchart.go @@ -0,0 +1,35 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import "github.com/gizak/termui" + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + bc := termui.NewBarChart() + data := []int{3, 2, 5, 3, 9, 5, 3, 2, 5, 8, 3, 2, 4, 5, 3, 2, 5, 7, 5, 3, 2, 6, 7, 4, 6, 3, 6, 7, 8, 3, 6, 4, 5, 3, 2, 4, 6, 4, 8, 5, 9, 4, 3, 6, 5, 3, 6} + bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} + bc.Border.Label = "Bar Chart" + bc.Data = data + bc.Width = 26 + bc.Height = 10 + bc.DataLabels = bclabels + bc.TextColor = termui.ColorGreen + bc.BarColor = termui.ColorRed + bc.NumColor = termui.ColorYellow + + termui.Render(bc) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/barchart.png b/Godeps/_workspace/src/github.com/gizak/termui/example/barchart.png new file mode 100644 index 000000000..a37912f7f Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/barchart.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.gif b/Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.gif new file mode 100644 index 000000000..8e1859c72 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.gif differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.go b/Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.go new file mode 100644 index 000000000..c14bb4413 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/dashboard.go @@ -0,0 +1,148 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import ui "github.com/gizak/termui" +import "math" + +import "time" + +func main() { + err := ui.Init() + if err != nil { + panic(err) + } + defer ui.Close() + + p := ui.NewPar(":PRESS q TO QUIT DEMO") + p.Height = 3 + p.Width = 50 + p.TextFgColor = ui.ColorWhite + p.Border.Label = "Text Box" + p.Border.FgColor = ui.ColorCyan + + strs := []string{"[0] gizak/termui", "[1] editbox.go", "[2] iterrupt.go", "[3] keyboard.go", "[4] output.go", "[5] random_out.go", "[6] dashboard.go", "[7] nsf/termbox-go"} + list := ui.NewList() + list.Items = strs + list.ItemFgColor = ui.ColorYellow + list.Border.Label = "List" + list.Height = 7 + list.Width = 25 + list.Y = 4 + + g := ui.NewGauge() + g.Percent = 50 + g.Width = 50 + g.Height = 3 + g.Y = 11 + g.Border.Label = "Gauge" + g.BarColor = ui.ColorRed + g.Border.FgColor = ui.ColorWhite + g.Border.LabelFgColor = ui.ColorCyan + + spark := ui.Sparkline{} + spark.Height = 1 + spark.Title = "srv 0:" + spdata := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6, 4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6, 4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6, 4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6} + spark.Data = spdata + spark.LineColor = ui.ColorCyan + spark.TitleColor = ui.ColorWhite + + spark1 := ui.Sparkline{} + spark1.Height = 1 + spark1.Title = "srv 1:" + spark1.Data = spdata + spark1.TitleColor = ui.ColorWhite + spark1.LineColor = ui.ColorRed + + sp := ui.NewSparklines(spark, spark1) + sp.Width = 25 + sp.Height = 7 + sp.Border.Label = "Sparkline" + sp.Y = 4 + sp.X = 25 + + sinps := (func() []float64 { + n := 220 + ps := make([]float64, n) + for i := range ps { + ps[i] = 1 + math.Sin(float64(i)/5) + } + return ps + })() + + lc := ui.NewLineChart() + lc.Border.Label = "dot-mode Line Chart" + lc.Data = sinps + lc.Width = 50 + lc.Height = 11 + lc.X = 0 + lc.Y = 14 + lc.AxesColor = ui.ColorWhite + lc.LineColor = ui.ColorRed | ui.AttrBold + lc.Mode = "dot" + + bc := ui.NewBarChart() + bcdata := []int{3, 2, 5, 3, 9, 5, 3, 2, 5, 8, 3, 2, 4, 5, 3, 2, 5, 7, 5, 3, 2, 6, 7, 4, 6, 3, 6, 7, 8, 3, 6, 4, 5, 3, 2, 4, 6, 4, 8, 5, 9, 4, 3, 6, 5, 3, 6} + bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} + bc.Border.Label = "Bar Chart" + bc.Width = 26 + bc.Height = 10 + bc.X = 51 + bc.Y = 0 + bc.DataLabels = bclabels + bc.BarColor = ui.ColorGreen + bc.NumColor = ui.ColorBlack + + lc1 := ui.NewLineChart() + lc1.Border.Label = "braille-mode Line Chart" + lc1.Data = sinps + lc1.Width = 26 + lc1.Height = 11 + lc1.X = 51 + lc1.Y = 14 + lc1.AxesColor = ui.ColorWhite + lc1.LineColor = ui.ColorYellow | ui.AttrBold + + p1 := ui.NewPar("Hey!\nI am a borderless block!") + p1.HasBorder = false + p1.Width = 26 + p1.Height = 2 + p1.TextFgColor = ui.ColorMagenta + p1.X = 52 + p1.Y = 11 + + draw := func(t int) { + g.Percent = t % 101 + list.Items = strs[t%9:] + sp.Lines[0].Data = spdata[:30+t%50] + sp.Lines[1].Data = spdata[:35+t%50] + lc.Data = sinps[t/2:] + lc1.Data = sinps[2*t:] + bc.Data = bcdata[t/2%10:] + ui.Render(p, list, g, sp, lc, bc, lc1, p1) + } + + evt := ui.EventCh() + + i := 0 + for { + select { + case e := <-evt: + if e.Type == ui.EventKey && e.Ch == 'q' { + return + } + default: + draw(i) + i++ + if i == 102 { + return + } + time.Sleep(time.Second / 2) + } + } +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/gauge.go b/Godeps/_workspace/src/github.com/gizak/termui/example/gauge.go new file mode 100644 index 000000000..b7033580f --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/gauge.go @@ -0,0 +1,62 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import "github.com/gizak/termui" + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + g0 := termui.NewGauge() + g0.Percent = 40 + g0.Width = 50 + g0.Height = 3 + g0.Border.Label = "Slim Gauge" + g0.BarColor = termui.ColorRed + g0.Border.FgColor = termui.ColorWhite + g0.Border.LabelFgColor = termui.ColorCyan + + g2 := termui.NewGauge() + g2.Percent = 60 + g2.Width = 50 + g2.Height = 3 + g2.PercentColor = termui.ColorBlue + g2.Y = 3 + g2.Border.Label = "Slim Gauge" + g2.BarColor = termui.ColorYellow + g2.Border.FgColor = termui.ColorWhite + + g1 := termui.NewGauge() + g1.Percent = 30 + g1.Width = 50 + g1.Height = 5 + g1.Y = 6 + g1.Border.Label = "Big Gauge" + g1.PercentColor = termui.ColorYellow + g1.BarColor = termui.ColorGreen + g1.Border.FgColor = termui.ColorWhite + g1.Border.LabelFgColor = termui.ColorMagenta + + g3 := termui.NewGauge() + g3.Percent = 50 + g3.Width = 50 + g3.Height = 3 + g3.Y = 11 + g3.Border.Label = "Gauge with custom label" + g3.Label = "{{percent}}% (100MBs free)" + g3.LabelAlign = termui.AlignRight + + termui.Render(g0, g1, g2, g3) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/gauge.png b/Godeps/_workspace/src/github.com/gizak/termui/example/gauge.png new file mode 100644 index 000000000..5c20e6e8a Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/gauge.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/grid.gif b/Godeps/_workspace/src/github.com/gizak/termui/example/grid.gif new file mode 100644 index 000000000..7490043de Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/grid.gif differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/grid.go b/Godeps/_workspace/src/github.com/gizak/termui/example/grid.go new file mode 100644 index 000000000..49121411f --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/grid.go @@ -0,0 +1,134 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import ui "github.com/gizak/termui" +import "math" +import "time" + +func main() { + err := ui.Init() + if err != nil { + panic(err) + } + defer ui.Close() + + sinps := (func() []float64 { + n := 400 + ps := make([]float64, n) + for i := range ps { + ps[i] = 1 + math.Sin(float64(i)/5) + } + return ps + })() + sinpsint := (func() []int { + ps := make([]int, len(sinps)) + for i, v := range sinps { + ps[i] = int(100*v + 10) + } + return ps + })() + + ui.UseTheme("helloworld") + + spark := ui.Sparkline{} + spark.Height = 8 + spdata := sinpsint + spark.Data = spdata[:100] + spark.LineColor = ui.ColorCyan + spark.TitleColor = ui.ColorWhite + + sp := ui.NewSparklines(spark) + sp.Height = 11 + sp.Border.Label = "Sparkline" + + lc := ui.NewLineChart() + lc.Border.Label = "braille-mode Line Chart" + lc.Data = sinps + lc.Height = 11 + lc.AxesColor = ui.ColorWhite + lc.LineColor = ui.ColorYellow | ui.AttrBold + + gs := make([]*ui.Gauge, 3) + for i := range gs { + gs[i] = ui.NewGauge() + gs[i].Height = 2 + gs[i].HasBorder = false + gs[i].Percent = i * 10 + gs[i].PaddingBottom = 1 + gs[i].BarColor = ui.ColorRed + } + + ls := ui.NewList() + ls.HasBorder = false + ls.Items = []string{ + "[1] Downloading File 1", + "", // == \newline + "[2] Downloading File 2", + "", + "[3] Uploading File 3", + } + ls.Height = 5 + + par := ui.NewPar("<> This row has 3 columns\n<- Widgets can be stacked up like left side\n<- Stacked widgets are treated as a single widget") + par.Height = 5 + par.Border.Label = "Demonstration" + + // build layout + ui.Body.AddRows( + ui.NewRow( + ui.NewCol(6, 0, sp), + ui.NewCol(6, 0, lc)), + ui.NewRow( + ui.NewCol(3, 0, ls), + ui.NewCol(3, 0, gs[0], gs[1], gs[2]), + ui.NewCol(6, 0, par))) + + // calculate layout + ui.Body.Align() + + done := make(chan bool) + redraw := make(chan bool) + + update := func() { + for i := 0; i < 103; i++ { + for _, g := range gs { + g.Percent = (g.Percent + 3) % 100 + } + + sp.Lines[0].Data = spdata[:100+i] + lc.Data = sinps[2*i:] + + time.Sleep(time.Second / 2) + redraw <- true + } + done <- true + } + + evt := ui.EventCh() + + ui.Render(ui.Body) + go update() + + for { + select { + case e := <-evt: + if e.Type == ui.EventKey && e.Ch == 'q' { + return + } + if e.Type == ui.EventResize { + ui.Body.Width = ui.TermWidth() + ui.Body.Align() + go func() { redraw <- true }() + } + case <-done: + return + case <-redraw: + ui.Render(ui.Body) + } + } +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/linechart.go b/Godeps/_workspace/src/github.com/gizak/termui/example/linechart.go new file mode 100644 index 000000000..1db543496 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/linechart.go @@ -0,0 +1,68 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import ( + "math" + + "github.com/gizak/termui" +) + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + sinps := (func() []float64 { + n := 220 + ps := make([]float64, n) + for i := range ps { + ps[i] = 1 + math.Sin(float64(i)/5) + } + return ps + })() + + lc0 := termui.NewLineChart() + lc0.Border.Label = "braille-mode Line Chart" + lc0.Data = sinps + lc0.Width = 50 + lc0.Height = 12 + lc0.X = 0 + lc0.Y = 0 + lc0.AxesColor = termui.ColorWhite + lc0.LineColor = termui.ColorGreen | termui.AttrBold + + lc1 := termui.NewLineChart() + lc1.Border.Label = "dot-mode Line Chart" + lc1.Mode = "dot" + lc1.Data = sinps + lc1.Width = 26 + lc1.Height = 12 + lc1.X = 51 + lc1.DotStyle = '+' + lc1.AxesColor = termui.ColorWhite + lc1.LineColor = termui.ColorYellow | termui.AttrBold + + lc2 := termui.NewLineChart() + lc2.Border.Label = "dot-mode Line Chart" + lc2.Mode = "dot" + lc2.Data = sinps[4:] + lc2.Width = 77 + lc2.Height = 16 + lc2.X = 0 + lc2.Y = 12 + lc2.AxesColor = termui.ColorWhite + lc2.LineColor = termui.ColorCyan | termui.AttrBold + + termui.Render(lc0, lc1, lc2) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/linechart.png b/Godeps/_workspace/src/github.com/gizak/termui/example/linechart.png new file mode 100644 index 000000000..655ef435f Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/linechart.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/list.go b/Godeps/_workspace/src/github.com/gizak/termui/example/list.go new file mode 100644 index 000000000..d33a3616c --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/list.go @@ -0,0 +1,41 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import "github.com/gizak/termui" + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + strs := []string{ + "[0] github.com/gizak/termui", + "[1] 你好，世界", + "[2] こんにちは世界", + "[3] keyboard.go", + "[4] output.go", + "[5] random_out.go", + "[6] dashboard.go", + "[7] nsf/termbox-go"} + + ls := termui.NewList() + ls.Items = strs + ls.ItemFgColor = termui.ColorYellow + ls.Border.Label = "List" + ls.Height = 7 + ls.Width = 25 + ls.Y = 0 + + termui.Render(ls) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/list.png b/Godeps/_workspace/src/github.com/gizak/termui/example/list.png new file mode 100644 index 000000000..8ca08c079 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/list.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.go b/Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.go new file mode 100644 index 000000000..a32a28e0a --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.go @@ -0,0 +1,50 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import "github.com/gizak/termui" + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + bc := termui.NewMBarChart() + math := []int{90, 85, 90, 80} + english := []int{70, 85, 75, 60} + science := []int{75, 60, 80, 85} + compsci := []int{100, 100, 100, 100} + bc.Data[0] = math + bc.Data[1] = english + bc.Data[2] = science + bc.Data[3] = compsci + studentsName := []string{"Ken", "Rob", "Dennis", "Linus"} + bc.Border.Label = "Student's Marks X-Axis=Name Y-Axis=Marks[Math,English,Science,ComputerScience] in %" + bc.Width = 100 + bc.Height = 50 + bc.Y = 10 + bc.BarWidth = 10 + bc.DataLabels = studentsName + bc.ShowScale = true //Show y_axis scale value (min and max) + bc.SetMax(400) + + bc.TextColor = termui.ColorGreen //this is color for label (x-axis) + bc.BarColor[3] = termui.ColorGreen //BarColor for computerscience + bc.BarColor[1] = termui.ColorYellow //Bar Color for english + bc.NumColor[3] = termui.ColorRed // Num color for computerscience + bc.NumColor[1] = termui.ColorRed // num color for english + + //Other colors are automatically populated, btw All the students seems do well in computerscience. :p + + termui.Render(bc) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.png b/Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.png new file mode 100644 index 000000000..9a4252616 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/mbarchart.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/par.go b/Godeps/_workspace/src/github.com/gizak/termui/example/par.go new file mode 100644 index 000000000..ffbc60aa8 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/par.go @@ -0,0 +1,48 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import "github.com/gizak/termui" + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + par0 := termui.NewPar("Borderless Text") + par0.Height = 1 + par0.Width = 20 + par0.Y = 1 + par0.HasBorder = false + + par1 := termui.NewPar("你好，世界。") + par1.Height = 3 + par1.Width = 17 + par1.X = 20 + par1.Border.Label = "标签" + + par2 := termui.NewPar("Simple text\nwith label. It can be multilined with \\n or break automatically") + par2.Height = 5 + par2.Width = 37 + par2.Y = 4 + par2.Border.Label = "Multiline" + par2.Border.FgColor = termui.ColorYellow + + par3 := termui.NewPar("Long text with label and it is auto trimmed.") + par3.Height = 3 + par3.Width = 37 + par3.Y = 9 + par3.Border.Label = "Auto Trim" + + termui.Render(par0, par1, par2, par3) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/par.png b/Godeps/_workspace/src/github.com/gizak/termui/example/par.png new file mode 100644 index 000000000..a85e64415 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/par.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.go b/Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.go new file mode 100644 index 000000000..f04baf570 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.go @@ -0,0 +1,65 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import "github.com/gizak/termui" + +func main() { + err := termui.Init() + if err != nil { + panic(err) + } + defer termui.Close() + + termui.UseTheme("helloworld") + + data := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6} + spl0 := termui.NewSparkline() + spl0.Data = data[3:] + spl0.Title = "Sparkline 0" + spl0.LineColor = termui.ColorGreen + + // single + spls0 := termui.NewSparklines(spl0) + spls0.Height = 2 + spls0.Width = 20 + spls0.HasBorder = false + + spl1 := termui.NewSparkline() + spl1.Data = data + spl1.Title = "Sparkline 1" + spl1.LineColor = termui.ColorRed + + spl2 := termui.NewSparkline() + spl2.Data = data[5:] + spl2.Title = "Sparkline 2" + spl2.LineColor = termui.ColorMagenta + + // group + spls1 := termui.NewSparklines(spl0, spl1, spl2) + spls1.Height = 8 + spls1.Width = 20 + spls1.Y = 3 + spls1.Border.Label = "Group Sparklines" + + spl3 := termui.NewSparkline() + spl3.Data = data + spl3.Title = "Enlarged Sparkline" + spl3.Height = 8 + spl3.LineColor = termui.ColorYellow + + spls2 := termui.NewSparklines(spl3) + spls2.Height = 11 + spls2.Width = 30 + spls2.Border.FgColor = termui.ColorCyan + spls2.X = 21 + spls2.Border.Label = "Tweeked Sparkline" + + termui.Render(spls0, spls1, spls2) + + <-termui.EventCh() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.png b/Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.png new file mode 100644 index 000000000..9dd7c82b1 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/sparklines.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/theme.go b/Godeps/_workspace/src/github.com/gizak/termui/example/theme.go new file mode 100644 index 000000000..30c51a343 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/example/theme.go @@ -0,0 +1,143 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +// +build ignore + +package main + +import ui "github.com/gizak/termui" +import "math" + +import "time" + +func main() { + err := ui.Init() + if err != nil { + panic(err) + } + defer ui.Close() + + ui.UseTheme("helloworld") + + p := ui.NewPar(":PRESS q TO QUIT DEMO") + p.Height = 3 + p.Width = 50 + p.Border.Label = "Text Box" + + strs := []string{"[0] gizak/termui", "[1] editbox.go", "[2] iterrupt.go", "[3] keyboard.go", "[4] output.go", "[5] random_out.go", "[6] dashboard.go", "[7] nsf/termbox-go"} + list := ui.NewList() + list.Items = strs + list.Border.Label = "List" + list.Height = 7 + list.Width = 25 + list.Y = 4 + + g := ui.NewGauge() + g.Percent = 50 + g.Width = 50 + g.Height = 3 + g.Y = 11 + g.Border.Label = "Gauge" + + spark := ui.NewSparkline() + spark.Title = "srv 0:" + spdata := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1, 7, 10, 10, 14, 13, 6} + spark.Data = spdata + + spark1 := ui.NewSparkline() + spark1.Title = "srv 1:" + spark1.Data = spdata + + sp := ui.NewSparklines(spark, spark1) + sp.Width = 25 + sp.Height = 7 + sp.Border.Label = "Sparkline" + sp.Y = 4 + sp.X = 25 + + lc := ui.NewLineChart() + sinps := (func() []float64 { + n := 100 + ps := make([]float64, n) + for i := range ps { + ps[i] = 1 + math.Sin(float64(i)/4) + } + return ps + })() + + lc.Border.Label = "Line Chart" + lc.Data = sinps + lc.Width = 50 + lc.Height = 11 + lc.X = 0 + lc.Y = 14 + lc.Mode = "dot" + + bc := ui.NewBarChart() + bcdata := []int{3, 2, 5, 3, 9, 5, 3, 2, 5, 8, 3, 2, 4, 5, 3, 2, 5, 7, 5, 3, 2, 6, 7, 4, 6, 3, 6, 7, 8, 3, 6, 4, 5, 3, 2, 4, 6, 4, 8, 5, 9, 4, 3, 6, 5, 3, 6} + bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} + bc.Border.Label = "Bar Chart" + bc.Width = 26 + bc.Height = 10 + bc.X = 51 + bc.Y = 0 + bc.DataLabels = bclabels + + lc1 := ui.NewLineChart() + lc1.Border.Label = "Line Chart" + rndwalk := (func() []float64 { + n := 150 + d := make([]float64, n) + for i := 1; i < n; i++ { + if i < 20 { + d[i] = d[i-1] + 0.01 + } + if i > 20 { + d[i] = d[i-1] - 0.05 + } + } + return d + })() + lc1.Data = rndwalk + lc1.Width = 26 + lc1.Height = 11 + lc1.X = 51 + lc1.Y = 14 + + p1 := ui.NewPar("Hey!\nI am a borderless block!") + p1.HasBorder = false + p1.Width = 26 + p1.Height = 2 + p1.X = 52 + p1.Y = 11 + + draw := func(t int) { + g.Percent = t % 101 + list.Items = strs[t%9:] + sp.Lines[0].Data = spdata[t%10:] + sp.Lines[1].Data = spdata[t/2%10:] + lc.Data = sinps[t/2:] + lc1.Data = rndwalk[t:] + bc.Data = bcdata[t/2%10:] + ui.Render(p, list, g, sp, lc, bc, lc1, p1) + } + + evt := ui.EventCh() + i := 0 + for { + select { + case e := <-evt: + if e.Type == ui.EventKey && e.Ch == 'q' { + return + } + default: + draw(i) + i++ + if i == 102 { + return + } + time.Sleep(time.Second / 2) + } + } +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/themedefault.png b/Godeps/_workspace/src/github.com/gizak/termui/example/themedefault.png new file mode 100644 index 000000000..23b574f96 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/themedefault.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/example/themehelloworld.png b/Godeps/_workspace/src/github.com/gizak/termui/example/themehelloworld.png new file mode 100644 index 000000000..eaf4d9303 Binary files /dev/null and b/Godeps/_workspace/src/github.com/gizak/termui/example/themehelloworld.png differ diff --git a/Godeps/_workspace/src/github.com/gizak/termui/gauge.go b/Godeps/_workspace/src/github.com/gizak/termui/gauge.go new file mode 100644 index 000000000..986f4f3dc --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/gauge.go @@ -0,0 +1,113 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import ( + "strconv" + "strings" +) + +// Gauge is a progress bar like widget. +// A simple example: +/* + g := termui.NewGauge() + g.Percent = 40 + g.Width = 50 + g.Height = 3 + g.Border.Label = "Slim Gauge" + g.BarColor = termui.ColorRed + g.PercentColor = termui.ColorBlue +*/ + +// Align is the position of the gauge's label. +type Align int + +// All supported positions. +const ( + AlignLeft Align = iota + AlignCenter + AlignRight +) + +type Gauge struct { + Block + Percent int + BarColor Attribute + PercentColor Attribute + Label string + LabelAlign Align +} + +// NewGauge return a new gauge with current theme. +func NewGauge() *Gauge { + g := &Gauge{ + Block: *NewBlock(), + PercentColor: theme.GaugePercent, + BarColor: theme.GaugeBar, + Label: "{{percent}}%", + LabelAlign: AlignCenter, + } + + g.Width = 12 + g.Height = 5 + return g +} + +// Buffer implements Bufferer interface. +func (g *Gauge) Buffer() []Point { + ps := g.Block.Buffer() + + // plot bar + w := g.Percent * g.innerWidth / 100 + for i := 0; i < g.innerHeight; i++ { + for j := 0; j < w; j++ { + p := Point{} + p.X = g.innerX + j + p.Y = g.innerY + i + p.Ch = ' ' + p.Bg = g.BarColor + if p.Bg == ColorDefault { + p.Bg |= AttrReverse + } + ps = append(ps, p) + } + } + + // plot percentage + s := strings.Replace(g.Label, "{{percent}}", strconv.Itoa(g.Percent), -1) + pry := g.innerY + g.innerHeight/2 + rs := str2runes(s) + var pos int + switch g.LabelAlign { + case AlignLeft: + pos = 0 + + case AlignCenter: + pos = (g.innerWidth - strWidth(s)) / 2 + + case AlignRight: + pos = g.innerWidth - strWidth(s) + } + + for i, v := range rs { + p := Point{} + p.X = 1 + pos + i + p.Y = pry + p.Ch = v + p.Fg = g.PercentColor + if w+g.innerX > pos+i { + p.Bg = g.BarColor + if p.Bg == ColorDefault { + p.Bg |= AttrReverse + } + + } else { + p.Bg = g.Block.BgColor + } + + ps = append(ps, p) + } + return g.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/grid.go b/Godeps/_workspace/src/github.com/gizak/termui/grid.go new file mode 100644 index 000000000..5f6e85e76 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/grid.go @@ -0,0 +1,279 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +// GridBufferer introduces a Bufferer that can be manipulated by Grid. +type GridBufferer interface { + Bufferer + GetHeight() int + SetWidth(int) + SetX(int) + SetY(int) +} + +// Row builds a layout tree +type Row struct { + Cols []*Row //children + Widget GridBufferer // root + X int + Y int + Width int + Height int + Span int + Offset int +} + +// calculate and set the underlying layout tree's x, y, height and width. +func (r *Row) calcLayout() { + r.assignWidth(r.Width) + r.Height = r.solveHeight() + r.assignX(r.X) + r.assignY(r.Y) +} + +// tell if the node is leaf in the tree. +func (r *Row) isLeaf() bool { + return r.Cols == nil || len(r.Cols) == 0 +} + +func (r *Row) isRenderableLeaf() bool { + return r.isLeaf() && r.Widget != nil +} + +// assign widgets' (and their parent rows') width recursively. +func (r *Row) assignWidth(w int) { + r.SetWidth(w) + + accW := 0 // acc span and offset + calcW := make([]int, len(r.Cols)) // calculated width + calcOftX := make([]int, len(r.Cols)) // computated start position of x + + for i, c := range r.Cols { + accW += c.Span + c.Offset + cw := int(float64(c.Span*r.Width) / 12.0) + + if i >= 1 { + calcOftX[i] = calcOftX[i-1] + + calcW[i-1] + + int(float64(r.Cols[i-1].Offset*r.Width)/12.0) + } + + // use up the space if it is the last col + if i == len(r.Cols)-1 && accW == 12 { + cw = r.Width - calcOftX[i] + } + calcW[i] = cw + r.Cols[i].assignWidth(cw) + } +} + +// bottom up calc and set rows' (and their widgets') height, +// return r's total height. +func (r *Row) solveHeight() int { + if r.isRenderableLeaf() { + r.Height = r.Widget.GetHeight() + return r.Widget.GetHeight() + } + + maxh := 0 + if !r.isLeaf() { + for _, c := range r.Cols { + nh := c.solveHeight() + // when embed rows in Cols, row widgets stack up + if r.Widget != nil { + nh += r.Widget.GetHeight() + } + if nh > maxh { + maxh = nh + } + } + } + + r.Height = maxh + return maxh +} + +// recursively assign x position for r tree. +func (r *Row) assignX(x int) { + r.SetX(x) + + if !r.isLeaf() { + acc := 0 + for i, c := range r.Cols { + if c.Offset != 0 { + acc += int(float64(c.Offset*r.Width) / 12.0) + } + r.Cols[i].assignX(x + acc) + acc += c.Width + } + } +} + +// recursively assign y position to r. +func (r *Row) assignY(y int) { + r.SetY(y) + + if r.isLeaf() { + return + } + + for i := range r.Cols { + acc := 0 + if r.Widget != nil { + acc = r.Widget.GetHeight() + } + r.Cols[i].assignY(y + acc) + } + +} + +// GetHeight implements GridBufferer interface. +func (r Row) GetHeight() int { + return r.Height +} + +// SetX implements GridBufferer interface. +func (r *Row) SetX(x int) { + r.X = x + if r.Widget != nil { + r.Widget.SetX(x) + } +} + +// SetY implements GridBufferer interface. +func (r *Row) SetY(y int) { + r.Y = y + if r.Widget != nil { + r.Widget.SetY(y) + } +} + +// SetWidth implements GridBufferer interface. +func (r *Row) SetWidth(w int) { + r.Width = w + if r.Widget != nil { + r.Widget.SetWidth(w) + } +} + +// Buffer implements Bufferer interface, +// recursively merge all widgets buffer +func (r *Row) Buffer() []Point { + merged := []Point{} + + if r.isRenderableLeaf() { + return r.Widget.Buffer() + } + + // for those are not leaves but have a renderable widget + if r.Widget != nil { + merged = append(merged, r.Widget.Buffer()...) + } + + // collect buffer from children + if !r.isLeaf() { + for _, c := range r.Cols { + merged = append(merged, c.Buffer()...) + } + } + + return merged +} + +// Grid implements 12 columns system. +// A simple example: +/* + import ui "github.com/gizak/termui" + // init and create widgets... + + // build + ui.Body.AddRows( + ui.NewRow( + ui.NewCol(6, 0, widget0), + ui.NewCol(6, 0, widget1)), + ui.NewRow( + ui.NewCol(3, 0, widget2), + ui.NewCol(3, 0, widget30, widget31, widget32), + ui.NewCol(6, 0, widget4))) + + // calculate layout + ui.Body.Align() + + ui.Render(ui.Body) +*/ +type Grid struct { + Rows []*Row + Width int + X int + Y int + BgColor Attribute +} + +// NewGrid returns *Grid with given rows. +func NewGrid(rows ...*Row) *Grid { + return &Grid{Rows: rows} +} + +// AddRows appends given rows to Grid. +func (g *Grid) AddRows(rs ...*Row) { + g.Rows = append(g.Rows, rs...) +} + +// NewRow creates a new row out of given columns. +func NewRow(cols ...*Row) *Row { + rs := &Row{Span: 12, Cols: cols} + return rs +} + +// NewCol accepts: widgets are LayoutBufferer or widgets is A NewRow. +// Note that if multiple widgets are provided, they will stack up in the col. +func NewCol(span, offset int, widgets ...GridBufferer) *Row { + r := &Row{Span: span, Offset: offset} + + if widgets != nil && len(widgets) == 1 { + wgt := widgets[0] + nw, isRow := wgt.(*Row) + if isRow { + r.Cols = nw.Cols + } else { + r.Widget = wgt + } + return r + } + + r.Cols = []*Row{} + ir := r + for _, w := range widgets { + nr := &Row{Span: 12, Widget: w} + ir.Cols = []*Row{nr} + ir = nr + } + + return r +} + +// Align calculate each rows' layout. +func (g *Grid) Align() { + h := 0 + for _, r := range g.Rows { + r.SetWidth(g.Width) + r.SetX(g.X) + r.SetY(g.Y + h) + r.calcLayout() + h += r.GetHeight() + } +} + +// Buffer implments Bufferer interface. +func (g Grid) Buffer() []Point { + ps := []Point{} + for _, r := range g.Rows { + ps = append(ps, r.Buffer()...) + } + return ps +} + +// Body corresponds to the entire terminal display region. +var Body *Grid diff --git a/Godeps/_workspace/src/github.com/gizak/termui/grid_test.go b/Godeps/_workspace/src/github.com/gizak/termui/grid_test.go new file mode 100644 index 000000000..cdafb2052 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/grid_test.go @@ -0,0 +1,98 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import ( + "testing" + + "github.com/davecgh/go-spew/spew" +) + +var r *Row + +func TestRowWidth(t *testing.T) { + p0 := NewPar("p0") + p0.Height = 1 + p1 := NewPar("p1") + p1.Height = 1 + p2 := NewPar("p2") + p2.Height = 1 + p3 := NewPar("p3") + p3.Height = 1 + + /* test against tree: + + r + / \ + 0:w 1 + / \ + 10:w 11 + / + 110:w + / + 1100:w + */ + /* + r = &row{ + Span: 12, + Cols: []*row{ + &row{Widget: p0, Span: 6}, + &row{ + Span: 6, + Cols: []*row{ + &row{Widget: p1, Span: 6}, + &row{ + Span: 6, + Cols: []*row{ + &row{ + Span: 12, + Widget: p2, + Cols: []*row{ + &row{Span: 12, Widget: p3}}}}}}}}} + */ + + r = NewRow( + NewCol(6, 0, p0), + NewCol(6, 0, + NewRow( + NewCol(6, 0, p1), + NewCol(6, 0, p2, p3)))) + + r.assignWidth(100) + if r.Width != 100 || + (r.Cols[0].Width) != 50 || + (r.Cols[1].Width) != 50 || + (r.Cols[1].Cols[0].Width) != 25 || + (r.Cols[1].Cols[1].Width) != 25 || + (r.Cols[1].Cols[1].Cols[0].Width) != 25 || + (r.Cols[1].Cols[1].Cols[0].Cols[0].Width) != 25 { + t.Error("assignWidth fails") + } +} + +func TestRowHeight(t *testing.T) { + spew.Dump() + + if (r.solveHeight()) != 2 || + (r.Cols[1].Cols[1].Height) != 2 || + (r.Cols[1].Cols[1].Cols[0].Height) != 2 || + (r.Cols[1].Cols[0].Height) != 1 { + t.Error("solveHeight fails") + } +} + +func TestAssignXY(t *testing.T) { + r.assignX(0) + r.assignY(0) + if (r.Cols[0].X) != 0 || + (r.Cols[1].Cols[0].X) != 50 || + (r.Cols[1].Cols[1].X) != 75 || + (r.Cols[1].Cols[1].Cols[0].X) != 75 || + (r.Cols[1].Cols[0].Y) != 0 || + (r.Cols[1].Cols[1].Cols[0].Y) != 0 || + (r.Cols[1].Cols[1].Cols[0].Cols[0].Y) != 1 { + t.Error("assignXY fails") + } +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/helper.go b/Godeps/_workspace/src/github.com/gizak/termui/helper.go new file mode 100644 index 000000000..80d8a0278 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/helper.go @@ -0,0 +1,66 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import tm "github.com/nsf/termbox-go" +import rw "github.com/mattn/go-runewidth" + +/* ---------------Port from termbox-go --------------------- */ + +// Attribute is printable cell's color and style. +type Attribute uint16 + +const ( + ColorDefault Attribute = iota + ColorBlack + ColorRed + ColorGreen + ColorYellow + ColorBlue + ColorMagenta + ColorCyan + ColorWhite +) + +const NumberofColors = 8 //Have a constant that defines number of colors +const ( + AttrBold Attribute = 1 << (iota + 9) + AttrUnderline + AttrReverse +) + +var ( + dot = "…" + dotw = rw.StringWidth(dot) +) + +/* ----------------------- End ----------------------------- */ + +func toTmAttr(x Attribute) tm.Attribute { + return tm.Attribute(x) +} + +func str2runes(s string) []rune { + return []rune(s) +} + +func trimStr2Runes(s string, w int) []rune { + if w <= 0 { + return []rune{} + } + sw := rw.StringWidth(s) + if sw > w { + return []rune(rw.Truncate(s, w, dot)) + } + return str2runes(s) //[]rune(rw.Truncate(s, w, "")) +} + +func strWidth(s string) int { + return rw.StringWidth(s) +} + +func charWidth(ch rune) int { + return rw.RuneWidth(ch) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/helper_test.go b/Godeps/_workspace/src/github.com/gizak/termui/helper_test.go new file mode 100644 index 000000000..6d1a56130 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/helper_test.go @@ -0,0 +1,58 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import ( + "testing" + + "github.com/davecgh/go-spew/spew" +) + +func TestStr2Rune(t *testing.T) { + s := "你好,世界." + rs := str2runes(s) + if len(rs) != 6 { + t.Error() + } +} + +func TestWidth(t *testing.T) { + s0 := "つのだ☆HIRO" + s1 := "11111111111" + spew.Dump(s0) + spew.Dump(s1) + // above not align for setting East Asian Ambiguous to wide!! + + if strWidth(s0) != strWidth(s1) { + t.Error("str len failed") + } + + len1 := []rune{'a', '2', '&', '｢', 'ｵ', '｡'} //will false: 'ᆵ', 'ᄚ', 'ᄒ' + for _, v := range len1 { + if charWidth(v) != 1 { + t.Error("len1 failed") + } + } + + len2 := []rune{'漢', '字', '한', '자', '你', '好', 'だ', '。', '％', 'ｓ', 'Ｅ', 'ョ', '、', 'ヲ'} + for _, v := range len2 { + if charWidth(v) != 2 { + t.Error("len2 failed") + } + } +} + +func TestTrim(t *testing.T) { + s := "つのだ☆HIRO" + if string(trimStr2Runes(s, 10)) != "つのだ☆HI"+dot { + t.Error("trim failed") + } + if string(trimStr2Runes(s, 11)) != "つのだ☆HIRO" { + t.Error("avoid tail trim failed") + } + if string(trimStr2Runes(s, 15)) != "つのだ☆HIRO" { + t.Error("avoid trim failed") + } +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/list.go b/Godeps/_workspace/src/github.com/gizak/termui/list.go new file mode 100644 index 000000000..0640932f2 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/list.go @@ -0,0 +1,104 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import "strings" + +// List displays []string as its items, +// it has a Overflow option (default is "hidden"), when set to "hidden", +// the item exceeding List's width is truncated, but when set to "wrap", +// the overflowed text breaks into next line. +/* + strs := []string{ + "[0] github.com/gizak/termui", + "[1] editbox.go", + "[2] iterrupt.go", + "[3] keyboard.go", + "[4] output.go", + "[5] random_out.go", + "[6] dashboard.go", + "[7] nsf/termbox-go"} + + ls := termui.NewList() + ls.Items = strs + ls.ItemFgColor = termui.ColorYellow + ls.Border.Label = "List" + ls.Height = 7 + ls.Width = 25 + ls.Y = 0 +*/ +type List struct { + Block + Items []string + Overflow string + ItemFgColor Attribute + ItemBgColor Attribute +} + +// NewList returns a new *List with current theme. +func NewList() *List { + l := &List{Block: *NewBlock()} + l.Overflow = "hidden" + l.ItemFgColor = theme.ListItemFg + l.ItemBgColor = theme.ListItemBg + return l +} + +// Buffer implements Bufferer interface. +func (l *List) Buffer() []Point { + ps := l.Block.Buffer() + switch l.Overflow { + case "wrap": + rs := str2runes(strings.Join(l.Items, "\n")) + i, j, k := 0, 0, 0 + for i < l.innerHeight && k < len(rs) { + w := charWidth(rs[k]) + if rs[k] == '\n' || j+w > l.innerWidth { + i++ + j = 0 + if rs[k] == '\n' { + k++ + } + continue + } + pi := Point{} + pi.X = l.innerX + j + pi.Y = l.innerY + i + + pi.Ch = rs[k] + pi.Bg = l.ItemBgColor + pi.Fg = l.ItemFgColor + + ps = append(ps, pi) + k++ + j++ + } + + case "hidden": + trimItems := l.Items + if len(trimItems) > l.innerHeight { + trimItems = trimItems[:l.innerHeight] + } + for i, v := range trimItems { + rs := trimStr2Runes(v, l.innerWidth) + + j := 0 + for _, vv := range rs { + w := charWidth(vv) + p := Point{} + p.X = l.innerX + j + p.Y = l.innerY + i + + p.Ch = vv + p.Bg = l.ItemBgColor + p.Fg = l.ItemFgColor + + ps = append(ps, p) + j += w + } + } + } + return l.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/mbar.go b/Godeps/_workspace/src/github.com/gizak/termui/mbar.go new file mode 100644 index 000000000..9d18c2cb4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/mbar.go @@ -0,0 +1,233 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import ( + "fmt" +) + +// This is the implemetation of multi-colored or stacked bar graph. This is different from default barGraph which is implemented in bar.go +// Multi-Colored-BarChart creates multiple bars in a widget: +/* + bc := termui.NewMBarChart() + data := make([][]int, 2) + data[0] := []int{3, 2, 5, 7, 9, 4} + data[1] := []int{7, 8, 5, 3, 1, 6} + bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} + bc.Border.Label = "Bar Chart" + bc.Data = data + bc.Width = 26 + bc.Height = 10 + bc.DataLabels = bclabels + bc.TextColor = termui.ColorGreen + bc.BarColor = termui.ColorRed + bc.NumColor = termui.ColorYellow +*/ +type MBarChart struct { + Block + BarColor [NumberofColors]Attribute + TextColor Attribute + NumColor [NumberofColors]Attribute + Data [NumberofColors][]int + DataLabels []string + BarWidth int + BarGap int + labels [][]rune + dataNum [NumberofColors][][]rune + numBar int + scale float64 + max int + minDataLen int + numStack int + ShowScale bool + maxScale []rune +} + +// NewBarChart returns a new *BarChart with current theme. +func NewMBarChart() *MBarChart { + bc := &MBarChart{Block: *NewBlock()} + bc.BarColor[0] = theme.MBarChartBar + bc.NumColor[0] = theme.MBarChartNum + bc.TextColor = theme.MBarChartText + bc.BarGap = 1 + bc.BarWidth = 3 + return bc +} + +func (bc *MBarChart) layout() { + bc.numBar = bc.innerWidth / (bc.BarGap + bc.BarWidth) + bc.labels = make([][]rune, bc.numBar) + DataLen := 0 + LabelLen := len(bc.DataLabels) + bc.minDataLen = 9999 //Set this to some very hight value so that we find the minimum one We want to know which array among data[][] has got the least length + + // We need to know how many stack/data array data[0] , data[1] are there + for i := 0; i < len(bc.Data); i++ { + if bc.Data[i] == nil { + break + } + DataLen++ + } + bc.numStack = DataLen + + //We need to know what is the mimimum size of data array data[0] could have 10 elements data[1] could have only 5, so we plot only 5 bar graphs + + for i := 0; i < DataLen; i++ { + if bc.minDataLen > len(bc.Data[i]) { + bc.minDataLen = len(bc.Data[i]) + } + } + + if LabelLen > bc.minDataLen { + LabelLen = bc.minDataLen + } + + for i := 0; i < LabelLen && i < bc.numBar; i++ { + bc.labels[i] = trimStr2Runes(bc.DataLabels[i], bc.BarWidth) + } + + for i := 0; i < bc.numStack; i++ { + bc.dataNum[i] = make([][]rune, len(bc.Data[i])) + //For each stack of bar calcualte the rune + for j := 0; j < LabelLen && i < bc.numBar; j++ { + n := bc.Data[i][j] + s := fmt.Sprint(n) + bc.dataNum[i][j] = trimStr2Runes(s, bc.BarWidth) + } + //If color is not defined by default then populate a color that is different from the prevous bar + if bc.BarColor[i] == ColorDefault && bc.NumColor[i] == ColorDefault { + if i == 0 { + bc.BarColor[i] = ColorBlack + } else { + bc.BarColor[i] = bc.BarColor[i-1] + 1 + if bc.BarColor[i] > NumberofColors { + bc.BarColor[i] = ColorBlack + } + } + bc.NumColor[i] = (NumberofColors + 1) - bc.BarColor[i] //Make NumColor opposite of barColor for visibility + } + } + + //If Max value is not set then we have to populate, this time the max value will be max(sum(d1[0],d2[0],d3[0]) .... sum(d1[n], d2[n], d3[n])) + + if bc.max == 0 { + bc.max = -1 + } + for i := 0; i < bc.minDataLen && i < LabelLen; i++ { + var dsum int + for j := 0; j < bc.numStack; j++ { + dsum += bc.Data[j][i] + } + if dsum > bc.max { + bc.max = dsum + } + } + + //Finally Calculate max sale + if bc.ShowScale { + s := fmt.Sprintf("%d", bc.max) + bc.maxScale = trimStr2Runes(s, len(s)) + bc.scale = float64(bc.max) / float64(bc.innerHeight-2) + } else { + bc.scale = float64(bc.max) / float64(bc.innerHeight-1) + } + +} + +func (bc *MBarChart) SetMax(max int) { + + if max > 0 { + bc.max = max + } +} + +// Buffer implements Bufferer interface. +func (bc *MBarChart) Buffer() []Point { + ps := bc.Block.Buffer() + bc.layout() + var oftX int + + for i := 0; i < bc.numBar && i < bc.minDataLen && i < len(bc.DataLabels); i++ { + ph := 0 //Previous Height to stack up + oftX = i * (bc.BarWidth + bc.BarGap) + for i1 := 0; i1 < bc.numStack; i1++ { + h := int(float64(bc.Data[i1][i]) / bc.scale) + // plot bars + for j := 0; j < bc.BarWidth; j++ { + for k := 0; k < h; k++ { + p := Point{} + p.Ch = ' ' + p.Bg = bc.BarColor[i1] + if bc.BarColor[i1] == ColorDefault { // when color is default, space char treated as transparent! + p.Bg |= AttrReverse + } + p.X = bc.innerX + i*(bc.BarWidth+bc.BarGap) + j + p.Y = bc.innerY + bc.innerHeight - 2 - k - ph + ps = append(ps, p) + } + } + ph += h + } + // plot text + for j, k := 0, 0; j < len(bc.labels[i]); j++ { + w := charWidth(bc.labels[i][j]) + p := Point{} + p.Ch = bc.labels[i][j] + p.Bg = bc.BgColor + p.Fg = bc.TextColor + p.Y = bc.innerY + bc.innerHeight - 1 + p.X = bc.innerX + oftX + ((bc.BarWidth - len(bc.labels[i])) / 2) + k + ps = append(ps, p) + k += w + } + // plot num + ph = 0 //re-initialize previous height + for i1 := 0; i1 < bc.numStack; i1++ { + h := int(float64(bc.Data[i1][i]) / bc.scale) + for j := 0; j < len(bc.dataNum[i1][i]) && h > 0; j++ { + p := Point{} + p.Ch = bc.dataNum[i1][i][j] + p.Fg = bc.NumColor[i1] + p.Bg = bc.BarColor[i1] + if bc.BarColor[i1] == ColorDefault { // the same as above + p.Bg |= AttrReverse + } + if h == 0 { + p.Bg = bc.BgColor + } + p.X = bc.innerX + oftX + (bc.BarWidth-len(bc.dataNum[i1][i]))/2 + j + p.Y = bc.innerY + bc.innerHeight - 2 - ph + ps = append(ps, p) + } + ph += h + } + } + + if bc.ShowScale { + //Currently bar graph only supprts data range from 0 to MAX + //Plot 0 + p := Point{} + p.Ch = '0' + p.Bg = bc.BgColor + p.Fg = bc.TextColor + p.Y = bc.innerY + bc.innerHeight - 2 + p.X = bc.X + ps = append(ps, p) + + //Plot the maximum sacle value + for i := 0; i < len(bc.maxScale); i++ { + p := Point{} + p.Ch = bc.maxScale[i] + p.Bg = bc.BgColor + p.Fg = bc.TextColor + p.Y = bc.innerY + p.X = bc.X + i + ps = append(ps, p) + } + + } + + return bc.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/p.go b/Godeps/_workspace/src/github.com/gizak/termui/p.go new file mode 100644 index 000000000..e327d7489 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/p.go @@ -0,0 +1,71 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +// Par displays a paragraph. +/* + par := termui.NewPar("Simple Text") + par.Height = 3 + par.Width = 17 + par.Border.Label = "Label" +*/ +type Par struct { + Block + Text string + TextFgColor Attribute + TextBgColor Attribute +} + +// NewPar returns a new *Par with given text as its content. +func NewPar(s string) *Par { + return &Par{ + Block: *NewBlock(), + Text: s, + TextFgColor: theme.ParTextFg, + TextBgColor: theme.ParTextBg} +} + +// Buffer implements Bufferer interface. +func (p *Par) Buffer() []Point { + ps := p.Block.Buffer() + + rs := str2runes(p.Text) + i, j, k := 0, 0, 0 + for i < p.innerHeight && k < len(rs) { + // the width of char is about to print + w := charWidth(rs[k]) + + if rs[k] == '\n' || j+w > p.innerWidth { + i++ + j = 0 // set x = 0 + if rs[k] == '\n' { + k++ + } + + if i >= p.innerHeight { + ps = append(ps, newPointWithAttrs('…', + p.innerX+p.innerWidth-1, + p.innerY+p.innerHeight-1, + p.TextFgColor, p.TextBgColor)) + break + } + + continue + } + pi := Point{} + pi.X = p.innerX + j + pi.Y = p.innerY + i + + pi.Ch = rs[k] + pi.Bg = p.TextBgColor + pi.Fg = p.TextFgColor + + ps = append(ps, pi) + + k++ + j += w + } + return p.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/point.go b/Godeps/_workspace/src/github.com/gizak/termui/point.go new file mode 100644 index 000000000..c381af9a4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/point.go @@ -0,0 +1,28 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +// Point stands for a single cell in terminal. +type Point struct { + Ch rune + Bg Attribute + Fg Attribute + X int + Y int +} + +func newPoint(c rune, x, y int) (p Point) { + p.Ch = c + p.X = x + p.Y = y + return +} + +func newPointWithAttrs(c rune, x, y int, fg, bg Attribute) Point { + p := newPoint(c, x, y) + p.Bg = bg + p.Fg = fg + return p +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/render.go b/Godeps/_workspace/src/github.com/gizak/termui/render.go new file mode 100644 index 000000000..d697d0aea --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/render.go @@ -0,0 +1,60 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import tm "github.com/nsf/termbox-go" + +// Bufferer should be implemented by all renderable components. +type Bufferer interface { + Buffer() []Point +} + +// Init initializes termui library. This function should be called before any others. +// After initialization, the library must be finalized by 'Close' function. +func Init() error { + Body = NewGrid() + Body.X = 0 + Body.Y = 0 + Body.BgColor = theme.BodyBg + defer func() { + w, _ := tm.Size() + Body.Width = w + evtListen() + }() + return tm.Init() +} + +// Close finalizes termui library, +// should be called after successful initialization when termui's functionality isn't required anymore. +func Close() { + tm.Close() +} + +// TermWidth returns the current terminal's width. +func TermWidth() int { + tm.Sync() + w, _ := tm.Size() + return w +} + +// TermHeight returns the current terminal's height. +func TermHeight() int { + tm.Sync() + _, h := tm.Size() + return h +} + +// Render renders all Bufferer in the given order from left to right, +// right could overlap on left ones. +func Render(rs ...Bufferer) { + tm.Clear(tm.ColorDefault, toTmAttr(theme.BodyBg)) + for _, r := range rs { + buf := r.Buffer() + for _, v := range buf { + tm.SetCell(v.X, v.Y, v.Ch, toTmAttr(v.Fg), toTmAttr(v.Bg)) + } + } + tm.Flush() +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/sparkline.go b/Godeps/_workspace/src/github.com/gizak/termui/sparkline.go new file mode 100644 index 000000000..c63a5857f --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/sparkline.go @@ -0,0 +1,156 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +import "math" + +// Sparkline is like: ▅▆▂▂▅▇▂▂▃▆▆▆▅▃ +/* + data := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1} + spl := termui.NewSparkline() + spl.Data = data + spl.Title = "Sparkline 0" + spl.LineColor = termui.ColorGreen +*/ +type Sparkline struct { + Data []int + Height int + Title string + TitleColor Attribute + LineColor Attribute + displayHeight int + scale float32 + max int +} + +// Sparklines is a renderable widget which groups together the given sparklines. +/* + spls := termui.NewSparklines(spl0,spl1,spl2) //... + spls.Height = 2 + spls.Width = 20 +*/ +type Sparklines struct { + Block + Lines []Sparkline + displayLines int + displayWidth int +} + +var sparks = []rune{'▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'} + +// Add appends a given Sparkline to s *Sparklines. +func (s *Sparklines) Add(sl Sparkline) { + s.Lines = append(s.Lines, sl) +} + +// NewSparkline returns a unrenderable single sparkline that intended to be added into Sparklines. +func NewSparkline() Sparkline { + return Sparkline{ + Height: 1, + TitleColor: theme.SparklineTitle, + LineColor: theme.SparklineLine} +} + +// NewSparklines return a new *Spaklines with given Sparkline(s), you can always add a new Sparkline later. +func NewSparklines(ss ...Sparkline) *Sparklines { + s := &Sparklines{Block: *NewBlock(), Lines: ss} + return s +} + +func (sl *Sparklines) update() { + for i, v := range sl.Lines { + if v.Title == "" { + sl.Lines[i].displayHeight = v.Height + } else { + sl.Lines[i].displayHeight = v.Height + 1 + } + } + sl.displayWidth = sl.innerWidth + + // get how many lines gotta display + h := 0 + sl.displayLines = 0 + for _, v := range sl.Lines { + if h+v.displayHeight <= sl.innerHeight { + sl.displayLines++ + } else { + break + } + h += v.displayHeight + } + + for i := 0; i < sl.displayLines; i++ { + data := sl.Lines[i].Data + + max := math.MinInt32 + for _, v := range data { + if max < v { + max = v + } + } + sl.Lines[i].max = max + sl.Lines[i].scale = float32(8*sl.Lines[i].Height) / float32(max) + } +} + +// Buffer implements Bufferer interface. +func (sl *Sparklines) Buffer() []Point { + ps := sl.Block.Buffer() + sl.update() + + oftY := 0 + for i := 0; i < sl.displayLines; i++ { + l := sl.Lines[i] + data := l.Data + + if len(data) > sl.innerWidth { + data = data[len(data)-sl.innerWidth:] + } + + if l.Title != "" { + rs := trimStr2Runes(l.Title, sl.innerWidth) + oftX := 0 + for _, v := range rs { + w := charWidth(v) + p := Point{} + p.Ch = v + p.Fg = l.TitleColor + p.Bg = sl.BgColor + p.X = sl.innerX + oftX + p.Y = sl.innerY + oftY + ps = append(ps, p) + oftX += w + } + } + + for j, v := range data { + h := int(float32(v)*l.scale + 0.5) + barCnt := h / 8 + barMod := h % 8 + for jj := 0; jj < barCnt; jj++ { + p := Point{} + p.X = sl.innerX + j + p.Y = sl.innerY + oftY + l.Height - jj + p.Ch = ' ' // => sparks[7] + p.Bg = l.LineColor + //p.Bg = sl.BgColor + ps = append(ps, p) + } + if barMod != 0 { + p := Point{} + p.X = sl.innerX + j + p.Y = sl.innerY + oftY + l.Height - barCnt + p.Ch = sparks[barMod-1] + p.Fg = l.LineColor + p.Bg = sl.BgColor + ps = append(ps, p) + } + } + + oftY += l.displayHeight + } + + return sl.Block.chopOverflow(ps) +} diff --git a/Godeps/_workspace/src/github.com/gizak/termui/theme.go b/Godeps/_workspace/src/github.com/gizak/termui/theme.go new file mode 100644 index 000000000..c8ad94756 --- /dev/null +++ b/Godeps/_workspace/src/github.com/gizak/termui/theme.go @@ -0,0 +1,84 @@ +// Copyright 2015 Zack Guo . All rights reserved. +// Use of this source code is governed by a MIT license that can +// be found in the LICENSE file. + +package termui + +// A ColorScheme represents the current look-and-feel of the dashboard. +type ColorScheme struct { + BodyBg Attribute + BlockBg Attribute + HasBorder bool + BorderFg Attribute + BorderBg Attribute + BorderLabelTextFg Attribute + BorderLabelTextBg Attribute + ParTextFg Attribute + ParTextBg Attribute + SparklineLine Attribute + SparklineTitle Attribute + GaugeBar Attribute + GaugePercent Attribute + LineChartLine Attribute + LineChartAxes Attribute + ListItemFg Attribute + ListItemBg Attribute + BarChartBar Attribute + BarChartText Attribute + BarChartNum Attribute + MBarChartBar Attribute + MBarChartText Attribute + MBarChartNum Attribute +} + +// default color scheme depends on the user's terminal setting. +var themeDefault = ColorScheme{HasBorder: true} + +var themeHelloWorld = ColorScheme{ + BodyBg: ColorBlack, + BlockBg: ColorBlack, + HasBorder: true, + BorderFg: ColorWhite, + BorderBg: ColorBlack, + BorderLabelTextBg: ColorBlack, + BorderLabelTextFg: ColorGreen, + ParTextBg: ColorBlack, + ParTextFg: ColorWhite, + SparklineLine: ColorMagenta, + SparklineTitle: ColorWhite, + GaugeBar: ColorRed, + GaugePercent: ColorWhite, + LineChartLine: ColorYellow | AttrBold, + LineChartAxes: ColorWhite, + ListItemBg: ColorBlack, + ListItemFg: ColorYellow, + BarChartBar: ColorRed, + BarChartNum: ColorWhite, + BarChartText: ColorCyan, + MBarChartBar: ColorRed, + MBarChartNum: ColorWhite, + MBarChartText: ColorCyan, +} + +var theme = themeDefault // global dep + +// Theme returns the currently used theme. +func Theme() ColorScheme { + return theme +} + +// SetTheme sets a new, custom theme. +func SetTheme(newTheme ColorScheme) { + theme = newTheme +} + +// UseTheme sets a predefined scheme. Currently available: "hello-world" and +// "black-and-white". +func UseTheme(th string) { + switch th { + case "helloworld": + theme = themeHelloWorld + default: + theme = themeDefault + } +} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/.gitignore b/Godeps/_workspace/src/github.com/howeyc/fsnotify/.gitignore deleted file mode 100644 index e4706a9e9..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -# Setup a Global .gitignore for OS and editor generated files: -# https://help.github.com/articles/ignoring-files -# git config --global core.excludesfile ~/.gitignore_global - -.vagrant diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/AUTHORS b/Godeps/_workspace/src/github.com/howeyc/fsnotify/AUTHORS deleted file mode 100644 index e52b72f83..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/AUTHORS +++ /dev/null @@ -1,28 +0,0 @@ -# Names should be added to this file as -# Name or Organization -# The email address is not required for organizations. - -# You can update this list using the following command: -# -# $ git shortlog -se | awk '{print $2 " " $3 " " $4}' - -# Please keep the list sorted. - -Adrien Bustany -Caleb Spare -Case Nelson -Chris Howey -Christoffer Buchholz -Dave Cheney -Francisco Souza -John C Barstow -Kelvin Fo -Nathan Youngman -Paul Hammond -Pursuit92 -Rob Figueiredo -Travis Cline -Tudor Golubenco -bronze1man -debrando -henrikedwards diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/CHANGELOG.md b/Godeps/_workspace/src/github.com/howeyc/fsnotify/CHANGELOG.md deleted file mode 100644 index 761686aa9..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/CHANGELOG.md +++ /dev/null @@ -1,160 +0,0 @@ -# Changelog - -## v0.9.0 / 2014-01-17 - -* IsAttrib() for events that only concern a file's metadata [#79][] (thanks @abustany) -* [Fix] kqueue: fix deadlock [#77][] (thanks @cespare) -* [NOTICE] Development has moved to `code.google.com/p/go.exp/fsnotify` in preparation for inclusion in the Go standard library. - -## v0.8.12 / 2013-11-13 - -* [API] Remove FD_SET and friends from Linux adapter - -## v0.8.11 / 2013-11-02 - -* [Doc] Add Changelog [#72][] (thanks @nathany) -* [Doc] Spotlight and double modify events on OS X [#62][] (reported by @paulhammond) - -## v0.8.10 / 2013-10-19 - -* [Fix] kqueue: remove file watches when parent directory is removed [#71][] (reported by @mdwhatcott) -* [Fix] kqueue: race between Close and readEvents [#70][] (reported by @bernerdschaefer) -* [Doc] specify OS-specific limits in README (thanks @debrando) - -## v0.8.9 / 2013-09-08 - -* [Doc] Contributing (thanks @nathany) -* [Doc] update package path in example code [#63][] (thanks @paulhammond) -* [Doc] GoCI badge in README (Linux only) [#60][] -* [Doc] Cross-platform testing with Vagrant [#59][] (thanks @nathany) - -## v0.8.8 / 2013-06-17 - -* [Fix] Windows: handle `ERROR_MORE_DATA` on Windows [#49][] (thanks @jbowtie) - -## v0.8.7 / 2013-06-03 - -* [API] Make syscall flags internal -* [Fix] inotify: ignore event changes -* [Fix] race in symlink test [#45][] (reported by @srid) -* [Fix] tests on Windows -* lower case error messages - -## v0.8.6 / 2013-05-23 - -* kqueue: Use EVT_ONLY flag on Darwin -* [Doc] Update README with full example - -## v0.8.5 / 2013-05-09 - -* [Fix] inotify: allow monitoring of "broken" symlinks (thanks @tsg) - -## v0.8.4 / 2013-04-07 - -* [Fix] kqueue: watch all file events [#40][] (thanks @ChrisBuchholz) - -## v0.8.3 / 2013-03-13 - -* [Fix] inoitfy/kqueue memory leak [#36][] (reported by @nbkolchin) -* [Fix] kqueue: use fsnFlags for watching a directory [#33][] (reported by @nbkolchin) - -## v0.8.2 / 2013-02-07 - -* [Doc] add Authors -* [Fix] fix data races for map access [#29][] (thanks @fsouza) - -## v0.8.1 / 2013-01-09 - -* [Fix] Windows path separators -* [Doc] BSD License - -## v0.8.0 / 2012-11-09 - -* kqueue: directory watching improvements (thanks @vmirage) -* inotify: add `IN_MOVED_TO` [#25][] (requested by @cpisto) -* [Fix] kqueue: deleting watched directory [#24][] (reported by @jakerr) - -## v0.7.4 / 2012-10-09 - -* [Fix] inotify: fixes from https://codereview.appspot.com/5418045/ (ugorji) -* [Fix] kqueue: preserve watch flags when watching for delete [#21][] (reported by @robfig) -* [Fix] kqueue: watch the directory even if it isn't a new watch (thanks @robfig) -* [Fix] kqueue: modify after recreation of file - -## v0.7.3 / 2012-09-27 - -* [Fix] kqueue: watch with an existing folder inside the watched folder (thanks @vmirage) -* [Fix] kqueue: no longer get duplicate CREATE events - -## v0.7.2 / 2012-09-01 - -* kqueue: events for created directories - -## v0.7.1 / 2012-07-14 - -* [Fix] for renaming files - -## v0.7.0 / 2012-07-02 - -* [Feature] FSNotify flags -* [Fix] inotify: Added file name back to event path - -## v0.6.0 / 2012-06-06 - -* kqueue: watch files after directory created (thanks @tmc) - -## v0.5.1 / 2012-05-22 - -* [Fix] inotify: remove all watches before Close() - -## v0.5.0 / 2012-05-03 - -* [API] kqueue: return errors during watch instead of sending over channel -* kqueue: match symlink behavior on Linux -* inotify: add `DELETE_SELF` (requested by @taralx) -* [Fix] kqueue: handle EINTR (reported by @robfig) -* [Doc] Godoc example [#1][] (thanks @davecheney) - -## v0.4.0 / 2012-03-30 - -* Go 1 released: build with go tool -* [Feature] Windows support using winfsnotify -* Windows does not have attribute change notifications -* Roll attribute notifications into IsModify - -## v0.3.0 / 2012-02-19 - -* kqueue: add files when watch directory - -## v0.2.0 / 2011-12-30 - -* update to latest Go weekly code - -## v0.1.0 / 2011-10-19 - -* kqueue: add watch on file creation to match inotify -* kqueue: create file event -* inotify: ignore `IN_IGNORED` events -* event String() -* linux: common FileEvent functions -* initial commit - -[#79]: https://github.com/howeyc/fsnotify/pull/79 -[#77]: https://github.com/howeyc/fsnotify/pull/77 -[#72]: https://github.com/howeyc/fsnotify/issues/72 -[#71]: https://github.com/howeyc/fsnotify/issues/71 -[#70]: https://github.com/howeyc/fsnotify/issues/70 -[#63]: https://github.com/howeyc/fsnotify/issues/63 -[#62]: https://github.com/howeyc/fsnotify/issues/62 -[#60]: https://github.com/howeyc/fsnotify/issues/60 -[#59]: https://github.com/howeyc/fsnotify/issues/59 -[#49]: https://github.com/howeyc/fsnotify/issues/49 -[#45]: https://github.com/howeyc/fsnotify/issues/45 -[#40]: https://github.com/howeyc/fsnotify/issues/40 -[#36]: https://github.com/howeyc/fsnotify/issues/36 -[#33]: https://github.com/howeyc/fsnotify/issues/33 -[#29]: https://github.com/howeyc/fsnotify/issues/29 -[#25]: https://github.com/howeyc/fsnotify/issues/25 -[#24]: https://github.com/howeyc/fsnotify/issues/24 -[#21]: https://github.com/howeyc/fsnotify/issues/21 -[#1]: https://github.com/howeyc/fsnotify/issues/1 diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/CONTRIBUTING.md b/Godeps/_workspace/src/github.com/howeyc/fsnotify/CONTRIBUTING.md deleted file mode 100644 index b2025d72c..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/CONTRIBUTING.md +++ /dev/null @@ -1,7 +0,0 @@ -# Contributing - -## Moving Notice - -There is a fork being actively developed with a new API in preparation for the Go Standard Library: -[github.com/go-fsnotify/fsnotify](https://github.com/go-fsnotify/fsnotify) - diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/LICENSE b/Godeps/_workspace/src/github.com/howeyc/fsnotify/LICENSE deleted file mode 100644 index f21e54080..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright (c) 2012 The Go Authors. All rights reserved. -Copyright (c) 2012 fsnotify Authors. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. 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. diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/README.md b/Godeps/_workspace/src/github.com/howeyc/fsnotify/README.md deleted file mode 100644 index 4c7498d38..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/README.md +++ /dev/null @@ -1,92 +0,0 @@ -# File system notifications for Go - -[![GoDoc](https://godoc.org/github.com/howeyc/fsnotify?status.png)](http://godoc.org/github.com/howeyc/fsnotify) - -Cross platform: Windows, Linux, BSD and OS X. - -## Moving Notice - -There is a fork being actively developed with a new API in preparation for the Go Standard Library: -[github.com/go-fsnotify/fsnotify](https://github.com/go-fsnotify/fsnotify) - -## Example: - -```go -package main - -import ( - "log" - - "github.com/howeyc/fsnotify" -) - -func main() { - watcher, err := fsnotify.NewWatcher() - if err != nil { - log.Fatal(err) - } - - done := make(chan bool) - - // Process events - go func() { - for { - select { - case ev := <-watcher.Event: - log.Println("event:", ev) - case err := <-watcher.Error: - log.Println("error:", err) - } - } - }() - - err = watcher.Watch("testDir") - if err != nil { - log.Fatal(err) - } - - <-done - - /* ... do stuff ... */ - watcher.Close() -} -``` - -For each event: -* Name -* IsCreate() -* IsDelete() -* IsModify() -* IsRename() - -## FAQ - -**When a file is moved to another directory is it still being watched?** - -No (it shouldn't be, unless you are watching where it was moved to). - -**When I watch a directory, are all subdirectories watched as well?** - -No, you must add watches for any directory you want to watch (a recursive watcher is in the works [#56][]). - -**Do I have to watch the Error and Event channels in a separate goroutine?** - -As of now, yes. Looking into making this single-thread friendly (see [#7][]) - -**Why am I receiving multiple events for the same file on OS X?** - -Spotlight indexing on OS X can result in multiple events (see [#62][]). A temporary workaround is to add your folder(s) to the *Spotlight Privacy settings* until we have a native FSEvents implementation (see [#54][]). - -**How many files can be watched at once?** - -There are OS-specific limits as to how many watches can be created: -* Linux: /proc/sys/fs/inotify/max_user_watches contains the limit, -reaching this limit results in a "no space left on device" error. -* BSD / OSX: sysctl variables "kern.maxfiles" and "kern.maxfilesperproc", reaching these limits results in a "too many open files" error. - - -[#62]: https://github.com/howeyc/fsnotify/issues/62 -[#56]: https://github.com/howeyc/fsnotify/issues/56 -[#54]: https://github.com/howeyc/fsnotify/issues/54 -[#7]: https://github.com/howeyc/fsnotify/issues/7 - diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/example_test.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/example_test.go deleted file mode 100644 index d3130e222..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/example_test.go +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package fsnotify_test - -import ( - "log" - - "github.com/howeyc/fsnotify" -) - -func ExampleNewWatcher() { - watcher, err := fsnotify.NewWatcher() - if err != nil { - log.Fatal(err) - } - - go func() { - for { - select { - case ev := <-watcher.Event: - log.Println("event:", ev) - case err := <-watcher.Error: - log.Println("error:", err) - } - } - }() - - err = watcher.Watch("/tmp/foo") - if err != nil { - log.Fatal(err) - } -} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify.go deleted file mode 100644 index 9a48d847d..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify.go +++ /dev/null @@ -1,111 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package fsnotify implements file system notification. -package fsnotify - -import "fmt" - -const ( - FSN_CREATE = 1 - FSN_MODIFY = 2 - FSN_DELETE = 4 - FSN_RENAME = 8 - - FSN_ALL = FSN_MODIFY | FSN_DELETE | FSN_RENAME | FSN_CREATE -) - -// Purge events from interal chan to external chan if passes filter -func (w *Watcher) purgeEvents() { - for ev := range w.internalEvent { - sendEvent := false - w.fsnmut.Lock() - fsnFlags := w.fsnFlags[ev.Name] - w.fsnmut.Unlock() - - if (fsnFlags&FSN_CREATE == FSN_CREATE) && ev.IsCreate() { - sendEvent = true - } - - if (fsnFlags&FSN_MODIFY == FSN_MODIFY) && ev.IsModify() { - sendEvent = true - } - - if (fsnFlags&FSN_DELETE == FSN_DELETE) && ev.IsDelete() { - sendEvent = true - } - - if (fsnFlags&FSN_RENAME == FSN_RENAME) && ev.IsRename() { - sendEvent = true - } - - if sendEvent { - w.Event <- ev - } - - // If there's no file, then no more events for user - // BSD must keep watch for internal use (watches DELETEs to keep track - // what files exist for create events) - if ev.IsDelete() { - w.fsnmut.Lock() - delete(w.fsnFlags, ev.Name) - w.fsnmut.Unlock() - } - } - - close(w.Event) -} - -// Watch a given file path -func (w *Watcher) Watch(path string) error { - return w.WatchFlags(path, FSN_ALL) -} - -// Watch a given file path for a particular set of notifications (FSN_MODIFY etc.) -func (w *Watcher) WatchFlags(path string, flags uint32) error { - w.fsnmut.Lock() - w.fsnFlags[path] = flags - w.fsnmut.Unlock() - return w.watch(path) -} - -// Remove a watch on a file -func (w *Watcher) RemoveWatch(path string) error { - w.fsnmut.Lock() - delete(w.fsnFlags, path) - w.fsnmut.Unlock() - return w.removeWatch(path) -} - -// String formats the event e in the form -// "filename: DELETE|MODIFY|..." -func (e *FileEvent) String() string { - var events string = "" - - if e.IsCreate() { - events += "|" + "CREATE" - } - - if e.IsDelete() { - events += "|" + "DELETE" - } - - if e.IsModify() { - events += "|" + "MODIFY" - } - - if e.IsRename() { - events += "|" + "RENAME" - } - - if e.IsAttrib() { - events += "|" + "ATTRIB" - } - - if len(events) > 0 { - events = events[1:] - } - - return fmt.Sprintf("%q: %s", e.Name, events) -} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_bsd.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_bsd.go deleted file mode 100644 index e6ffd7e5b..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_bsd.go +++ /dev/null @@ -1,496 +0,0 @@ -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build freebsd openbsd netbsd darwin - -package fsnotify - -import ( - "errors" - "fmt" - "io/ioutil" - "os" - "path/filepath" - "sync" - "syscall" -) - -const ( - // Flags (from ) - sys_NOTE_DELETE = 0x0001 /* vnode was removed */ - sys_NOTE_WRITE = 0x0002 /* data contents changed */ - sys_NOTE_EXTEND = 0x0004 /* size increased */ - sys_NOTE_ATTRIB = 0x0008 /* attributes changed */ - sys_NOTE_LINK = 0x0010 /* link count changed */ - sys_NOTE_RENAME = 0x0020 /* vnode was renamed */ - sys_NOTE_REVOKE = 0x0040 /* vnode access was revoked */ - - // Watch all events - sys_NOTE_ALLEVENTS = sys_NOTE_DELETE | sys_NOTE_WRITE | sys_NOTE_ATTRIB | sys_NOTE_RENAME - - // Block for 100 ms on each call to kevent - keventWaitTime = 100e6 -) - -type FileEvent struct { - mask uint32 // Mask of events - Name string // File name (optional) - create bool // set by fsnotify package if found new file -} - -// IsCreate reports whether the FileEvent was triggered by a creation -func (e *FileEvent) IsCreate() bool { return e.create } - -// IsDelete reports whether the FileEvent was triggered by a delete -func (e *FileEvent) IsDelete() bool { return (e.mask & sys_NOTE_DELETE) == sys_NOTE_DELETE } - -// IsModify reports whether the FileEvent was triggered by a file modification -func (e *FileEvent) IsModify() bool { - return ((e.mask&sys_NOTE_WRITE) == sys_NOTE_WRITE || (e.mask&sys_NOTE_ATTRIB) == sys_NOTE_ATTRIB) -} - -// IsRename reports whether the FileEvent was triggered by a change name -func (e *FileEvent) IsRename() bool { return (e.mask & sys_NOTE_RENAME) == sys_NOTE_RENAME } - -// IsAttrib reports whether the FileEvent was triggered by a change in the file metadata. -func (e *FileEvent) IsAttrib() bool { - return (e.mask & sys_NOTE_ATTRIB) == sys_NOTE_ATTRIB -} - -type Watcher struct { - mu sync.Mutex // Mutex for the Watcher itself. - kq int // File descriptor (as returned by the kqueue() syscall) - watches map[string]int // Map of watched file descriptors (key: path) - wmut sync.Mutex // Protects access to watches. - fsnFlags map[string]uint32 // Map of watched files to flags used for filter - fsnmut sync.Mutex // Protects access to fsnFlags. - enFlags map[string]uint32 // Map of watched files to evfilt note flags used in kqueue - enmut sync.Mutex // Protects access to enFlags. - paths map[int]string // Map of watched paths (key: watch descriptor) - finfo map[int]os.FileInfo // Map of file information (isDir, isReg; key: watch descriptor) - pmut sync.Mutex // Protects access to paths and finfo. - fileExists map[string]bool // Keep track of if we know this file exists (to stop duplicate create events) - femut sync.Mutex // Protects access to fileExists. - externalWatches map[string]bool // Map of watches added by user of the library. - ewmut sync.Mutex // Protects access to externalWatches. - Error chan error // Errors are sent on this channel - internalEvent chan *FileEvent // Events are queued on this channel - Event chan *FileEvent // Events are returned on this channel - done chan bool // Channel for sending a "quit message" to the reader goroutine - isClosed bool // Set to true when Close() is first called -} - -// NewWatcher creates and returns a new kevent instance using kqueue(2) -func NewWatcher() (*Watcher, error) { - fd, errno := syscall.Kqueue() - if fd == -1 { - return nil, os.NewSyscallError("kqueue", errno) - } - w := &Watcher{ - kq: fd, - watches: make(map[string]int), - fsnFlags: make(map[string]uint32), - enFlags: make(map[string]uint32), - paths: make(map[int]string), - finfo: make(map[int]os.FileInfo), - fileExists: make(map[string]bool), - externalWatches: make(map[string]bool), - internalEvent: make(chan *FileEvent), - Event: make(chan *FileEvent), - Error: make(chan error), - done: make(chan bool, 1), - } - - go w.readEvents() - go w.purgeEvents() - return w, nil -} - -// Close closes a kevent watcher instance -// It sends a message to the reader goroutine to quit and removes all watches -// associated with the kevent instance -func (w *Watcher) Close() error { - w.mu.Lock() - if w.isClosed { - w.mu.Unlock() - return nil - } - w.isClosed = true - w.mu.Unlock() - - // Send "quit" message to the reader goroutine - w.done <- true - w.wmut.Lock() - ws := w.watches - w.wmut.Unlock() - for path := range ws { - w.removeWatch(path) - } - - return nil -} - -// AddWatch adds path to the watched file set. -// The flags are interpreted as described in kevent(2). -func (w *Watcher) addWatch(path string, flags uint32) error { - w.mu.Lock() - if w.isClosed { - w.mu.Unlock() - return errors.New("kevent instance already closed") - } - w.mu.Unlock() - - watchDir := false - - w.wmut.Lock() - watchfd, found := w.watches[path] - w.wmut.Unlock() - if !found { - fi, errstat := os.Lstat(path) - if errstat != nil { - return errstat - } - - // don't watch socket - if fi.Mode()&os.ModeSocket == os.ModeSocket { - return nil - } - - // Follow Symlinks - // Unfortunately, Linux can add bogus symlinks to watch list without - // issue, and Windows can't do symlinks period (AFAIK). To maintain - // consistency, we will act like everything is fine. There will simply - // be no file events for broken symlinks. - // Hence the returns of nil on errors. - if fi.Mode()&os.ModeSymlink == os.ModeSymlink { - path, err := filepath.EvalSymlinks(path) - if err != nil { - return nil - } - - fi, errstat = os.Lstat(path) - if errstat != nil { - return nil - } - } - - fd, errno := syscall.Open(path, open_FLAGS, 0700) - if fd == -1 { - return errno - } - watchfd = fd - - w.wmut.Lock() - w.watches[path] = watchfd - w.wmut.Unlock() - - w.pmut.Lock() - w.paths[watchfd] = path - w.finfo[watchfd] = fi - w.pmut.Unlock() - } - // Watch the directory if it has not been watched before. - w.pmut.Lock() - w.enmut.Lock() - if w.finfo[watchfd].IsDir() && - (flags&sys_NOTE_WRITE) == sys_NOTE_WRITE && - (!found || (w.enFlags[path]&sys_NOTE_WRITE) != sys_NOTE_WRITE) { - watchDir = true - } - w.enmut.Unlock() - w.pmut.Unlock() - - w.enmut.Lock() - w.enFlags[path] = flags - w.enmut.Unlock() - - var kbuf [1]syscall.Kevent_t - watchEntry := &kbuf[0] - watchEntry.Fflags = flags - syscall.SetKevent(watchEntry, watchfd, syscall.EVFILT_VNODE, syscall.EV_ADD|syscall.EV_CLEAR) - entryFlags := watchEntry.Flags - success, errno := syscall.Kevent(w.kq, kbuf[:], nil, nil) - if success == -1 { - return errno - } else if (entryFlags & syscall.EV_ERROR) == syscall.EV_ERROR { - return errors.New("kevent add error") - } - - if watchDir { - errdir := w.watchDirectoryFiles(path) - if errdir != nil { - return errdir - } - } - return nil -} - -// Watch adds path to the watched file set, watching all events. -func (w *Watcher) watch(path string) error { - w.ewmut.Lock() - w.externalWatches[path] = true - w.ewmut.Unlock() - return w.addWatch(path, sys_NOTE_ALLEVENTS) -} - -// RemoveWatch removes path from the watched file set. -func (w *Watcher) removeWatch(path string) error { - w.wmut.Lock() - watchfd, ok := w.watches[path] - w.wmut.Unlock() - if !ok { - return errors.New(fmt.Sprintf("can't remove non-existent kevent watch for: %s", path)) - } - var kbuf [1]syscall.Kevent_t - watchEntry := &kbuf[0] - syscall.SetKevent(watchEntry, watchfd, syscall.EVFILT_VNODE, syscall.EV_DELETE) - entryFlags := watchEntry.Flags - success, errno := syscall.Kevent(w.kq, kbuf[:], nil, nil) - if success == -1 { - return os.NewSyscallError("kevent_rm_watch", errno) - } else if (entryFlags & syscall.EV_ERROR) == syscall.EV_ERROR { - return errors.New("kevent rm error") - } - syscall.Close(watchfd) - w.wmut.Lock() - delete(w.watches, path) - w.wmut.Unlock() - w.enmut.Lock() - delete(w.enFlags, path) - w.enmut.Unlock() - w.pmut.Lock() - delete(w.paths, watchfd) - fInfo := w.finfo[watchfd] - delete(w.finfo, watchfd) - w.pmut.Unlock() - - // Find all watched paths that are in this directory that are not external. - if fInfo.IsDir() { - var pathsToRemove []string - w.pmut.Lock() - for _, wpath := range w.paths { - wdir, _ := filepath.Split(wpath) - if filepath.Clean(wdir) == filepath.Clean(path) { - w.ewmut.Lock() - if !w.externalWatches[wpath] { - pathsToRemove = append(pathsToRemove, wpath) - } - w.ewmut.Unlock() - } - } - w.pmut.Unlock() - for _, p := range pathsToRemove { - // Since these are internal, not much sense in propagating error - // to the user, as that will just confuse them with an error about - // a path they did not explicitly watch themselves. - w.removeWatch(p) - } - } - - return nil -} - -// readEvents reads from the kqueue file descriptor, converts the -// received events into Event objects and sends them via the Event channel -func (w *Watcher) readEvents() { - var ( - eventbuf [10]syscall.Kevent_t // Event buffer - events []syscall.Kevent_t // Received events - twait *syscall.Timespec // Time to block waiting for events - n int // Number of events returned from kevent - errno error // Syscall errno - ) - events = eventbuf[0:0] - twait = new(syscall.Timespec) - *twait = syscall.NsecToTimespec(keventWaitTime) - - for { - // See if there is a message on the "done" channel - var done bool - select { - case done = <-w.done: - default: - } - - // If "done" message is received - if done { - errno := syscall.Close(w.kq) - if errno != nil { - w.Error <- os.NewSyscallError("close", errno) - } - close(w.internalEvent) - close(w.Error) - return - } - - // Get new events - if len(events) == 0 { - n, errno = syscall.Kevent(w.kq, nil, eventbuf[:], twait) - - // EINTR is okay, basically the syscall was interrupted before - // timeout expired. - if errno != nil && errno != syscall.EINTR { - w.Error <- os.NewSyscallError("kevent", errno) - continue - } - - // Received some events - if n > 0 { - events = eventbuf[0:n] - } - } - - // Flush the events we received to the events channel - for len(events) > 0 { - fileEvent := new(FileEvent) - watchEvent := &events[0] - fileEvent.mask = uint32(watchEvent.Fflags) - w.pmut.Lock() - fileEvent.Name = w.paths[int(watchEvent.Ident)] - fileInfo := w.finfo[int(watchEvent.Ident)] - w.pmut.Unlock() - if fileInfo != nil && fileInfo.IsDir() && !fileEvent.IsDelete() { - // Double check to make sure the directory exist. This can happen when - // we do a rm -fr on a recursively watched folders and we receive a - // modification event first but the folder has been deleted and later - // receive the delete event - if _, err := os.Lstat(fileEvent.Name); os.IsNotExist(err) { - // mark is as delete event - fileEvent.mask |= sys_NOTE_DELETE - } - } - - if fileInfo != nil && fileInfo.IsDir() && fileEvent.IsModify() && !fileEvent.IsDelete() { - w.sendDirectoryChangeEvents(fileEvent.Name) - } else { - // Send the event on the events channel - w.internalEvent <- fileEvent - } - - // Move to next event - events = events[1:] - - if fileEvent.IsRename() { - w.removeWatch(fileEvent.Name) - w.femut.Lock() - delete(w.fileExists, fileEvent.Name) - w.femut.Unlock() - } - if fileEvent.IsDelete() { - w.removeWatch(fileEvent.Name) - w.femut.Lock() - delete(w.fileExists, fileEvent.Name) - w.femut.Unlock() - - // Look for a file that may have overwritten this - // (ie mv f1 f2 will delete f2 then create f2) - fileDir, _ := filepath.Split(fileEvent.Name) - fileDir = filepath.Clean(fileDir) - w.wmut.Lock() - _, found := w.watches[fileDir] - w.wmut.Unlock() - if found { - // make sure the directory exist before we watch for changes. When we - // do a recursive watch and perform rm -fr, the parent directory might - // have gone missing, ignore the missing directory and let the - // upcoming delete event remove the watch form the parent folder - if _, err := os.Lstat(fileDir); !os.IsNotExist(err) { - w.sendDirectoryChangeEvents(fileDir) - } - } - } - } - } -} - -func (w *Watcher) watchDirectoryFiles(dirPath string) error { - // Get all files - files, err := ioutil.ReadDir(dirPath) - if err != nil { - return err - } - - // Search for new files - for _, fileInfo := range files { - filePath := filepath.Join(dirPath, fileInfo.Name()) - - // Inherit fsnFlags from parent directory - w.fsnmut.Lock() - if flags, found := w.fsnFlags[dirPath]; found { - w.fsnFlags[filePath] = flags - } else { - w.fsnFlags[filePath] = FSN_ALL - } - w.fsnmut.Unlock() - - if fileInfo.IsDir() == false { - // Watch file to mimic linux fsnotify - e := w.addWatch(filePath, sys_NOTE_ALLEVENTS) - if e != nil { - return e - } - } else { - // If the user is currently watching directory - // we want to preserve the flags used - w.enmut.Lock() - currFlags, found := w.enFlags[filePath] - w.enmut.Unlock() - var newFlags uint32 = sys_NOTE_DELETE - if found { - newFlags |= currFlags - } - - // Linux gives deletes if not explicitly watching - e := w.addWatch(filePath, newFlags) - if e != nil { - return e - } - } - w.femut.Lock() - w.fileExists[filePath] = true - w.femut.Unlock() - } - - return nil -} - -// sendDirectoryEvents searches the directory for newly created files -// and sends them over the event channel. This functionality is to have -// the BSD version of fsnotify match linux fsnotify which provides a -// create event for files created in a watched directory. -func (w *Watcher) sendDirectoryChangeEvents(dirPath string) { - // Get all files - files, err := ioutil.ReadDir(dirPath) - if err != nil { - w.Error <- err - } - - // Search for new files - for _, fileInfo := range files { - filePath := filepath.Join(dirPath, fileInfo.Name()) - w.femut.Lock() - _, doesExist := w.fileExists[filePath] - w.femut.Unlock() - if !doesExist { - // Inherit fsnFlags from parent directory - w.fsnmut.Lock() - if flags, found := w.fsnFlags[dirPath]; found { - w.fsnFlags[filePath] = flags - } else { - w.fsnFlags[filePath] = FSN_ALL - } - w.fsnmut.Unlock() - - // Send create event - fileEvent := new(FileEvent) - fileEvent.Name = filePath - fileEvent.create = true - w.internalEvent <- fileEvent - } - w.femut.Lock() - w.fileExists[filePath] = true - w.femut.Unlock() - } - w.watchDirectoryFiles(dirPath) -} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_linux.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_linux.go deleted file mode 100644 index 80ade879f..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_linux.go +++ /dev/null @@ -1,304 +0,0 @@ -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build linux - -package fsnotify - -import ( - "errors" - "fmt" - "os" - "strings" - "sync" - "syscall" - "unsafe" -) - -const ( - // Options for inotify_init() are not exported - // sys_IN_CLOEXEC uint32 = syscall.IN_CLOEXEC - // sys_IN_NONBLOCK uint32 = syscall.IN_NONBLOCK - - // Options for AddWatch - sys_IN_DONT_FOLLOW uint32 = syscall.IN_DONT_FOLLOW - sys_IN_ONESHOT uint32 = syscall.IN_ONESHOT - sys_IN_ONLYDIR uint32 = syscall.IN_ONLYDIR - - // The "sys_IN_MASK_ADD" option is not exported, as AddWatch - // adds it automatically, if there is already a watch for the given path - // sys_IN_MASK_ADD uint32 = syscall.IN_MASK_ADD - - // Events - sys_IN_ACCESS uint32 = syscall.IN_ACCESS - sys_IN_ALL_EVENTS uint32 = syscall.IN_ALL_EVENTS - sys_IN_ATTRIB uint32 = syscall.IN_ATTRIB - sys_IN_CLOSE uint32 = syscall.IN_CLOSE - sys_IN_CLOSE_NOWRITE uint32 = syscall.IN_CLOSE_NOWRITE - sys_IN_CLOSE_WRITE uint32 = syscall.IN_CLOSE_WRITE - sys_IN_CREATE uint32 = syscall.IN_CREATE - sys_IN_DELETE uint32 = syscall.IN_DELETE - sys_IN_DELETE_SELF uint32 = syscall.IN_DELETE_SELF - sys_IN_MODIFY uint32 = syscall.IN_MODIFY - sys_IN_MOVE uint32 = syscall.IN_MOVE - sys_IN_MOVED_FROM uint32 = syscall.IN_MOVED_FROM - sys_IN_MOVED_TO uint32 = syscall.IN_MOVED_TO - sys_IN_MOVE_SELF uint32 = syscall.IN_MOVE_SELF - sys_IN_OPEN uint32 = syscall.IN_OPEN - - sys_AGNOSTIC_EVENTS = sys_IN_MOVED_TO | sys_IN_MOVED_FROM | sys_IN_CREATE | sys_IN_ATTRIB | sys_IN_MODIFY | sys_IN_MOVE_SELF | sys_IN_DELETE | sys_IN_DELETE_SELF - - // Special events - sys_IN_ISDIR uint32 = syscall.IN_ISDIR - sys_IN_IGNORED uint32 = syscall.IN_IGNORED - sys_IN_Q_OVERFLOW uint32 = syscall.IN_Q_OVERFLOW - sys_IN_UNMOUNT uint32 = syscall.IN_UNMOUNT -) - -type FileEvent struct { - mask uint32 // Mask of events - cookie uint32 // Unique cookie associating related events (for rename(2)) - Name string // File name (optional) -} - -// IsCreate reports whether the FileEvent was triggered by a creation -func (e *FileEvent) IsCreate() bool { - return (e.mask&sys_IN_CREATE) == sys_IN_CREATE || (e.mask&sys_IN_MOVED_TO) == sys_IN_MOVED_TO -} - -// IsDelete reports whether the FileEvent was triggered by a delete -func (e *FileEvent) IsDelete() bool { - return (e.mask&sys_IN_DELETE_SELF) == sys_IN_DELETE_SELF || (e.mask&sys_IN_DELETE) == sys_IN_DELETE -} - -// IsModify reports whether the FileEvent was triggered by a file modification or attribute change -func (e *FileEvent) IsModify() bool { - return ((e.mask&sys_IN_MODIFY) == sys_IN_MODIFY || (e.mask&sys_IN_ATTRIB) == sys_IN_ATTRIB) -} - -// IsRename reports whether the FileEvent was triggered by a change name -func (e *FileEvent) IsRename() bool { - return ((e.mask&sys_IN_MOVE_SELF) == sys_IN_MOVE_SELF || (e.mask&sys_IN_MOVED_FROM) == sys_IN_MOVED_FROM) -} - -// IsAttrib reports whether the FileEvent was triggered by a change in the file metadata. -func (e *FileEvent) IsAttrib() bool { - return (e.mask & sys_IN_ATTRIB) == sys_IN_ATTRIB -} - -type watch struct { - wd uint32 // Watch descriptor (as returned by the inotify_add_watch() syscall) - flags uint32 // inotify flags of this watch (see inotify(7) for the list of valid flags) -} - -type Watcher struct { - mu sync.Mutex // Map access - fd int // File descriptor (as returned by the inotify_init() syscall) - watches map[string]*watch // Map of inotify watches (key: path) - fsnFlags map[string]uint32 // Map of watched files to flags used for filter - fsnmut sync.Mutex // Protects access to fsnFlags. - paths map[int]string // Map of watched paths (key: watch descriptor) - Error chan error // Errors are sent on this channel - internalEvent chan *FileEvent // Events are queued on this channel - Event chan *FileEvent // Events are returned on this channel - done chan bool // Channel for sending a "quit message" to the reader goroutine - isClosed bool // Set to true when Close() is first called -} - -// NewWatcher creates and returns a new inotify instance using inotify_init(2) -func NewWatcher() (*Watcher, error) { - fd, errno := syscall.InotifyInit() - if fd == -1 { - return nil, os.NewSyscallError("inotify_init", errno) - } - w := &Watcher{ - fd: fd, - watches: make(map[string]*watch), - fsnFlags: make(map[string]uint32), - paths: make(map[int]string), - internalEvent: make(chan *FileEvent), - Event: make(chan *FileEvent), - Error: make(chan error), - done: make(chan bool, 1), - } - - go w.readEvents() - go w.purgeEvents() - return w, nil -} - -// Close closes an inotify watcher instance -// It sends a message to the reader goroutine to quit and removes all watches -// associated with the inotify instance -func (w *Watcher) Close() error { - if w.isClosed { - return nil - } - w.isClosed = true - - // Remove all watches - for path := range w.watches { - w.RemoveWatch(path) - } - - // Send "quit" message to the reader goroutine - w.done <- true - - return nil -} - -// AddWatch adds path to the watched file set. -// The flags are interpreted as described in inotify_add_watch(2). -func (w *Watcher) addWatch(path string, flags uint32) error { - if w.isClosed { - return errors.New("inotify instance already closed") - } - - w.mu.Lock() - watchEntry, found := w.watches[path] - w.mu.Unlock() - if found { - watchEntry.flags |= flags - flags |= syscall.IN_MASK_ADD - } - wd, errno := syscall.InotifyAddWatch(w.fd, path, flags) - if wd == -1 { - return errno - } - - w.mu.Lock() - w.watches[path] = &watch{wd: uint32(wd), flags: flags} - w.paths[wd] = path - w.mu.Unlock() - - return nil -} - -// Watch adds path to the watched file set, watching all events. -func (w *Watcher) watch(path string) error { - return w.addWatch(path, sys_AGNOSTIC_EVENTS) -} - -// RemoveWatch removes path from the watched file set. -func (w *Watcher) removeWatch(path string) error { - w.mu.Lock() - defer w.mu.Unlock() - watch, ok := w.watches[path] - if !ok { - return errors.New(fmt.Sprintf("can't remove non-existent inotify watch for: %s", path)) - } - success, errno := syscall.InotifyRmWatch(w.fd, watch.wd) - if success == -1 { - return os.NewSyscallError("inotify_rm_watch", errno) - } - delete(w.watches, path) - return nil -} - -// readEvents reads from the inotify file descriptor, converts the -// received events into Event objects and sends them via the Event channel -func (w *Watcher) readEvents() { - var ( - buf [syscall.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events - n int // Number of bytes read with read() - errno error // Syscall errno - ) - - for { - // See if there is a message on the "done" channel - select { - case <-w.done: - syscall.Close(w.fd) - close(w.internalEvent) - close(w.Error) - return - default: - } - - n, errno = syscall.Read(w.fd, buf[:]) - - // If EOF is received - if n == 0 { - syscall.Close(w.fd) - close(w.internalEvent) - close(w.Error) - return - } - - if n < 0 { - w.Error <- os.NewSyscallError("read", errno) - continue - } - if n < syscall.SizeofInotifyEvent { - w.Error <- errors.New("inotify: short read in readEvents()") - continue - } - - var offset uint32 = 0 - // We don't know how many events we just read into the buffer - // While the offset points to at least one whole event... - for offset <= uint32(n-syscall.SizeofInotifyEvent) { - // Point "raw" to the event in the buffer - raw := (*syscall.InotifyEvent)(unsafe.Pointer(&buf[offset])) - event := new(FileEvent) - event.mask = uint32(raw.Mask) - event.cookie = uint32(raw.Cookie) - nameLen := uint32(raw.Len) - // If the event happened to the watched directory or the watched file, the kernel - // doesn't append the filename to the event, but we would like to always fill the - // the "Name" field with a valid filename. We retrieve the path of the watch from - // the "paths" map. - w.mu.Lock() - event.Name = w.paths[int(raw.Wd)] - w.mu.Unlock() - watchedName := event.Name - if nameLen > 0 { - // Point "bytes" at the first byte of the filename - bytes := (*[syscall.PathMax]byte)(unsafe.Pointer(&buf[offset+syscall.SizeofInotifyEvent])) - // The filename is padded with NUL bytes. TrimRight() gets rid of those. - event.Name += "/" + strings.TrimRight(string(bytes[0:nameLen]), "\000") - } - - // Send the events that are not ignored on the events channel - if !event.ignoreLinux() { - // Setup FSNotify flags (inherit from directory watch) - w.fsnmut.Lock() - if _, fsnFound := w.fsnFlags[event.Name]; !fsnFound { - if fsnFlags, watchFound := w.fsnFlags[watchedName]; watchFound { - w.fsnFlags[event.Name] = fsnFlags - } else { - w.fsnFlags[event.Name] = FSN_ALL - } - } - w.fsnmut.Unlock() - - w.internalEvent <- event - } - - // Move to the next event in the buffer - offset += syscall.SizeofInotifyEvent + nameLen - } - } -} - -// Certain types of events can be "ignored" and not sent over the Event -// channel. Such as events marked ignore by the kernel, or MODIFY events -// against files that do not exist. -func (e *FileEvent) ignoreLinux() bool { - // Ignore anything the inotify API says to ignore - if e.mask&sys_IN_IGNORED == sys_IN_IGNORED { - return true - } - - // If the event is not a DELETE or RENAME, the file must exist. - // Otherwise the event is ignored. - // *Note*: this was put in place because it was seen that a MODIFY - // event was sent after the DELETE. This ignores that MODIFY and - // assumes a DELETE will come or has come if the file doesn't exist. - if !(e.IsDelete() || e.IsRename()) { - _, statErr := os.Lstat(e.Name) - return os.IsNotExist(statErr) - } - return false -} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_open_bsd.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_open_bsd.go deleted file mode 100644 index 37ea998d0..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_open_bsd.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build freebsd openbsd netbsd - -package fsnotify - -import "syscall" - -const open_FLAGS = syscall.O_NONBLOCK | syscall.O_RDONLY diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_open_darwin.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_open_darwin.go deleted file mode 100644 index d450318e6..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_open_darwin.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build darwin - -package fsnotify - -import "syscall" - -const open_FLAGS = syscall.O_EVTONLY diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_symlink_test.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_symlink_test.go deleted file mode 100644 index 39061f844..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_symlink_test.go +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build freebsd openbsd netbsd darwin linux - -package fsnotify - -import ( - "os" - "path/filepath" - "testing" - "time" -) - -func TestFsnotifyFakeSymlink(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - var errorsReceived counter - // Receive errors on the error channel on a separate goroutine - go func() { - for errors := range watcher.Error { - t.Logf("Received error: %s", errors) - errorsReceived.increment() - } - }() - - // Count the CREATE events received - var createEventsReceived, otherEventsReceived counter - go func() { - for ev := range watcher.Event { - t.Logf("event received: %s", ev) - if ev.IsCreate() { - createEventsReceived.increment() - } else { - otherEventsReceived.increment() - } - } - }() - - addWatch(t, watcher, testDir) - - if err := os.Symlink(filepath.Join(testDir, "zzz"), filepath.Join(testDir, "zzznew")); err != nil { - t.Fatalf("Failed to create bogus symlink: %s", err) - } - t.Logf("Created bogus symlink") - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - - // Should not be error, just no events for broken links (watching nothing) - if errorsReceived.value() > 0 { - t.Fatal("fsnotify errors have been received.") - } - if otherEventsReceived.value() > 0 { - t.Fatal("fsnotify other events received on the broken link") - } - - // Except for 1 create event (for the link itself) - if createEventsReceived.value() == 0 { - t.Fatal("fsnotify create events were not received after 500 ms") - } - if createEventsReceived.value() > 1 { - t.Fatal("fsnotify more create events received than expected") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() -} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_test.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_test.go deleted file mode 100644 index 3f5a6487f..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_test.go +++ /dev/null @@ -1,1010 +0,0 @@ -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package fsnotify - -import ( - "io/ioutil" - "os" - "os/exec" - "path/filepath" - "runtime" - "sync/atomic" - "testing" - "time" -) - -// An atomic counter -type counter struct { - val int32 -} - -func (c *counter) increment() { - atomic.AddInt32(&c.val, 1) -} - -func (c *counter) value() int32 { - return atomic.LoadInt32(&c.val) -} - -func (c *counter) reset() { - atomic.StoreInt32(&c.val, 0) -} - -// tempMkdir makes a temporary directory -func tempMkdir(t *testing.T) string { - dir, err := ioutil.TempDir("", "fsnotify") - if err != nil { - t.Fatalf("failed to create test directory: %s", err) - } - return dir -} - -// newWatcher initializes an fsnotify Watcher instance. -func newWatcher(t *testing.T) *Watcher { - watcher, err := NewWatcher() - if err != nil { - t.Fatalf("NewWatcher() failed: %s", err) - } - return watcher -} - -// addWatch adds a watch for a directory -func addWatch(t *testing.T, watcher *Watcher, dir string) { - if err := watcher.Watch(dir); err != nil { - t.Fatalf("watcher.Watch(%q) failed: %s", dir, err) - } -} - -func TestFsnotifyMultipleOperations(t *testing.T) { - watcher := newWatcher(t) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create directory that's not watched - testDirToMoveFiles := tempMkdir(t) - defer os.RemoveAll(testDirToMoveFiles) - - testFile := filepath.Join(testDir, "TestFsnotifySeq.testfile") - testFileRenamed := filepath.Join(testDirToMoveFiles, "TestFsnotifySeqRename.testfile") - - addWatch(t, watcher, testDir) - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var createReceived, modifyReceived, deleteReceived, renameReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) { - t.Logf("event received: %s", event) - if event.IsDelete() { - deleteReceived.increment() - } - if event.IsModify() { - modifyReceived.increment() - } - if event.IsCreate() { - createReceived.increment() - } - if event.IsRename() { - renameReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // Modify the file outside of the watched dir - f, err = os.Open(testFileRenamed) - if err != nil { - t.Fatalf("open test renamed file failed: %s", err) - } - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Recreate the file that was moved - f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Close() - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 2 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 2) - } - mReceived := modifyReceived.value() - if mReceived != 1 { - t.Fatalf("incorrect number of modify events received after 500 ms (%d vs %d)", mReceived, 1) - } - dReceived := deleteReceived.value() - rReceived := renameReceived.value() - if dReceived+rReceived != 1 { - t.Fatalf("incorrect number of rename+delete events received after 500 ms (%d vs %d)", rReceived+dReceived, 1) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyMultipleCreates(t *testing.T) { - watcher := newWatcher(t) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - testFile := filepath.Join(testDir, "TestFsnotifySeq.testfile") - - addWatch(t, watcher, testDir) - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var createReceived, modifyReceived, deleteReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) { - t.Logf("event received: %s", event) - if event.IsDelete() { - deleteReceived.increment() - } - if event.IsCreate() { - createReceived.increment() - } - if event.IsModify() { - modifyReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - os.Remove(testFile) - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Recreate the file - f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Close() - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Modify - f, err = os.OpenFile(testFile, os.O_WRONLY, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // Modify - f, err = os.OpenFile(testFile, os.O_WRONLY, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 2 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 2) - } - mReceived := modifyReceived.value() - if mReceived < 3 { - t.Fatalf("incorrect number of modify events received after 500 ms (%d vs atleast %d)", mReceived, 3) - } - dReceived := deleteReceived.value() - if dReceived != 1 { - t.Fatalf("incorrect number of rename+delete events received after 500 ms (%d vs %d)", dReceived, 1) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyDirOnly(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - // This should NOT add any events to the fsnotify event queue - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDir, "TestFsnotifyDirOnly.testfile") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var createReceived, modifyReceived, deleteReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileAlreadyExists) { - t.Logf("event received: %s", event) - if event.IsDelete() { - deleteReceived.increment() - } - if event.IsModify() { - modifyReceived.increment() - } - if event.IsCreate() { - createReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - time.Sleep(time.Millisecond) - f.WriteString("data") - f.Sync() - f.Close() - - time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete - - os.Remove(testFile) - os.Remove(testFileAlreadyExists) - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 1 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 1) - } - mReceived := modifyReceived.value() - if mReceived != 1 { - t.Fatalf("incorrect number of modify events received after 500 ms (%d vs %d)", mReceived, 1) - } - dReceived := deleteReceived.value() - if dReceived != 2 { - t.Fatalf("incorrect number of delete events received after 500 ms (%d vs %d)", dReceived, 2) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyDeleteWatchedDir(t *testing.T) { - watcher := newWatcher(t) - defer watcher.Close() - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - addWatch(t, watcher, testDir) - - // Add a watch for testFile - addWatch(t, watcher, testFileAlreadyExists) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var deleteReceived counter - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFileAlreadyExists) { - t.Logf("event received: %s", event) - if event.IsDelete() { - deleteReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - }() - - os.RemoveAll(testDir) - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - dReceived := deleteReceived.value() - if dReceived < 2 { - t.Fatalf("did not receive at least %d delete events, received %d after 500 ms", 2, dReceived) - } -} - -func TestFsnotifySubDir(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - testFile1 := filepath.Join(testDir, "TestFsnotifyFile1.testfile") - testSubDir := filepath.Join(testDir, "sub") - testSubDirFile := filepath.Join(testDir, "sub/TestFsnotifyFile1.testfile") - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var createReceived, deleteReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testSubDir) || event.Name == filepath.Clean(testFile1) { - t.Logf("event received: %s", event) - if event.IsCreate() { - createReceived.increment() - } - if event.IsDelete() { - deleteReceived.increment() - } - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - addWatch(t, watcher, testDir) - - // Create sub-directory - if err := os.Mkdir(testSubDir, 0777); err != nil { - t.Fatalf("failed to create test sub-directory: %s", err) - } - - // Create a file - var f *os.File - f, err := os.OpenFile(testFile1, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - - // Create a file (Should not see this! we are not watching subdir) - var fs *os.File - fs, err = os.OpenFile(testSubDirFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - fs.Sync() - fs.Close() - - time.Sleep(200 * time.Millisecond) - - // Make sure receive deletes for both file and sub-directory - os.RemoveAll(testSubDir) - os.Remove(testFile1) - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - cReceived := createReceived.value() - if cReceived != 2 { - t.Fatalf("incorrect number of create events received after 500 ms (%d vs %d)", cReceived, 2) - } - dReceived := deleteReceived.value() - if dReceived != 2 { - t.Fatalf("incorrect number of delete events received after 500 ms (%d vs %d)", dReceived, 2) - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } -} - -func TestFsnotifyRename(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDir, "TestFsnotifyEvents.testfile") - testFileRenamed := filepath.Join(testDir, "TestFsnotifyEvents.testfileRenamed") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var renameReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileRenamed) { - if event.IsRename() { - renameReceived.increment() - } - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - f.WriteString("data") - f.Sync() - f.Close() - - // Add a watch for testFile - addWatch(t, watcher, testFile) - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - if renameReceived.value() == 0 { - t.Fatal("fsnotify rename events have not been received after 500 ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } - - os.Remove(testFileRenamed) -} - -func TestFsnotifyRenameToCreate(t *testing.T) { - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create directory to get file - testDirFrom := tempMkdir(t) - defer os.RemoveAll(testDirFrom) - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDirFrom, "TestFsnotifyEvents.testfile") - testFileRenamed := filepath.Join(testDir, "TestFsnotifyEvents.testfileRenamed") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var createReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileRenamed) { - if event.IsCreate() { - createReceived.increment() - } - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - if createReceived.value() == 0 { - t.Fatal("fsnotify create events have not been received after 500 ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } - - os.Remove(testFileRenamed) -} - -func TestFsnotifyRenameToOverwrite(t *testing.T) { - switch runtime.GOOS { - case "plan9", "windows": - t.Skipf("skipping test on %q (os.Rename over existing file does not create event).", runtime.GOOS) - } - - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create directory to get file - testDirFrom := tempMkdir(t) - defer os.RemoveAll(testDirFrom) - - testFile := filepath.Join(testDirFrom, "TestFsnotifyEvents.testfile") - testFileRenamed := filepath.Join(testDir, "TestFsnotifyEvents.testfileRenamed") - - // Create a file - var fr *os.File - fr, err := os.OpenFile(testFileRenamed, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - fr.Sync() - fr.Close() - - addWatch(t, watcher, testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - var eventReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testFileRenamed) { - eventReceived.increment() - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - - if err := testRename(testFile, testFileRenamed); err != nil { - t.Fatalf("rename failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - time.Sleep(500 * time.Millisecond) - if eventReceived.value() == 0 { - t.Fatal("fsnotify events have not been received after 500 ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(2 * time.Second): - t.Fatal("event stream was not closed after 2 seconds") - } - - os.Remove(testFileRenamed) -} - -func TestRemovalOfWatch(t *testing.T) { - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Create a file before watching directory - testFileAlreadyExists := filepath.Join(testDir, "TestFsnotifyEventsExisting.testfile") - { - var f *os.File - f, err := os.OpenFile(testFileAlreadyExists, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - f.Close() - } - - watcher := newWatcher(t) - defer watcher.Close() - - addWatch(t, watcher, testDir) - if err := watcher.RemoveWatch(testDir); err != nil { - t.Fatalf("Could not remove the watch: %v\n", err) - } - - go func() { - select { - case ev := <-watcher.Event: - t.Fatalf("We received event: %v\n", ev) - case <-time.After(500 * time.Millisecond): - t.Log("No event received, as expected.") - } - }() - - time.Sleep(200 * time.Millisecond) - // Modify the file outside of the watched dir - f, err := os.Open(testFileAlreadyExists) - if err != nil { - t.Fatalf("Open test file failed: %s", err) - } - f.WriteString("data") - f.Sync() - f.Close() - if err := os.Chmod(testFileAlreadyExists, 0700); err != nil { - t.Fatalf("chmod failed: %s", err) - } - time.Sleep(400 * time.Millisecond) -} - -func TestFsnotifyAttrib(t *testing.T) { - if runtime.GOOS == "windows" { - t.Skip("attributes don't work on Windows.") - } - - watcher := newWatcher(t) - - // Create directory to watch - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - // Receive errors on the error channel on a separate goroutine - go func() { - for err := range watcher.Error { - t.Fatalf("error received: %s", err) - } - }() - - testFile := filepath.Join(testDir, "TestFsnotifyAttrib.testfile") - - // Receive events on the event channel on a separate goroutine - eventstream := watcher.Event - // The modifyReceived counter counts IsModify events that are not IsAttrib, - // and the attribReceived counts IsAttrib events (which are also IsModify as - // a consequence). - var modifyReceived counter - var attribReceived counter - done := make(chan bool) - go func() { - for event := range eventstream { - // Only count relevant events - if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) { - if event.IsModify() { - modifyReceived.increment() - } - if event.IsAttrib() { - attribReceived.increment() - } - t.Logf("event received: %s", event) - } else { - t.Logf("unexpected event received: %s", event) - } - } - done <- true - }() - - // Create a file - // This should add at least one event to the fsnotify event queue - var f *os.File - f, err := os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666) - if err != nil { - t.Fatalf("creating test file failed: %s", err) - } - f.Sync() - - f.WriteString("data") - f.Sync() - f.Close() - - // Add a watch for testFile - addWatch(t, watcher, testFile) - - if err := os.Chmod(testFile, 0700); err != nil { - t.Fatalf("chmod failed: %s", err) - } - - // We expect this event to be received almost immediately, but let's wait 500 ms to be sure - // Creating/writing a file changes also the mtime, so IsAttrib should be set to true here - time.Sleep(500 * time.Millisecond) - if modifyReceived.value() == 0 { - t.Fatal("fsnotify modify events have not received after 500 ms") - } - if attribReceived.value() == 0 { - t.Fatal("fsnotify attribute events have not received after 500 ms") - } - - // Modifying the contents of the file does not set the attrib flag (although eg. the mtime - // might have been modified). - modifyReceived.reset() - attribReceived.reset() - - f, err = os.OpenFile(testFile, os.O_WRONLY, 0) - if err != nil { - t.Fatalf("reopening test file failed: %s", err) - } - - f.WriteString("more data") - f.Sync() - f.Close() - - time.Sleep(500 * time.Millisecond) - - if modifyReceived.value() != 1 { - t.Fatal("didn't receive a modify event after changing test file contents") - } - - if attribReceived.value() != 0 { - t.Fatal("did receive an unexpected attrib event after changing test file contents") - } - - modifyReceived.reset() - attribReceived.reset() - - // Doing a chmod on the file should trigger an event with the "attrib" flag set (the contents - // of the file are not changed though) - if err := os.Chmod(testFile, 0600); err != nil { - t.Fatalf("chmod failed: %s", err) - } - - time.Sleep(500 * time.Millisecond) - - if attribReceived.value() != 1 { - t.Fatal("didn't receive an attribute change after 500ms") - } - - // Try closing the fsnotify instance - t.Log("calling Close()") - watcher.Close() - t.Log("waiting for the event channel to become closed...") - select { - case <-done: - t.Log("event channel closed") - case <-time.After(1e9): - t.Fatal("event stream was not closed after 1 second") - } - - os.Remove(testFile) -} - -func TestFsnotifyClose(t *testing.T) { - watcher := newWatcher(t) - watcher.Close() - - var done int32 - go func() { - watcher.Close() - atomic.StoreInt32(&done, 1) - }() - - time.Sleep(50e6) // 50 ms - if atomic.LoadInt32(&done) == 0 { - t.Fatal("double Close() test failed: second Close() call didn't return") - } - - testDir := tempMkdir(t) - defer os.RemoveAll(testDir) - - if err := watcher.Watch(testDir); err == nil { - t.Fatal("expected error on Watch() after Close(), got nil") - } -} - -func testRename(file1, file2 string) error { - switch runtime.GOOS { - case "windows", "plan9": - return os.Rename(file1, file2) - default: - cmd := exec.Command("mv", file1, file2) - return cmd.Run() - } -} diff --git a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_windows.go b/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_windows.go deleted file mode 100644 index d88ae6340..000000000 --- a/Godeps/_workspace/src/github.com/howeyc/fsnotify/fsnotify_windows.go +++ /dev/null @@ -1,598 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build windows - -package fsnotify - -import ( - "errors" - "fmt" - "os" - "path/filepath" - "runtime" - "sync" - "syscall" - "unsafe" -) - -const ( - // Options for AddWatch - sys_FS_ONESHOT = 0x80000000 - sys_FS_ONLYDIR = 0x1000000 - - // Events - sys_FS_ACCESS = 0x1 - sys_FS_ALL_EVENTS = 0xfff - sys_FS_ATTRIB = 0x4 - sys_FS_CLOSE = 0x18 - sys_FS_CREATE = 0x100 - sys_FS_DELETE = 0x200 - sys_FS_DELETE_SELF = 0x400 - sys_FS_MODIFY = 0x2 - sys_FS_MOVE = 0xc0 - sys_FS_MOVED_FROM = 0x40 - sys_FS_MOVED_TO = 0x80 - sys_FS_MOVE_SELF = 0x800 - - // Special events - sys_FS_IGNORED = 0x8000 - sys_FS_Q_OVERFLOW = 0x4000 -) - -const ( - // TODO(nj): Use syscall.ERROR_MORE_DATA from ztypes_windows in Go 1.3+ - sys_ERROR_MORE_DATA syscall.Errno = 234 -) - -// Event is the type of the notification messages -// received on the watcher's Event channel. -type FileEvent struct { - mask uint32 // Mask of events - cookie uint32 // Unique cookie associating related events (for rename) - Name string // File name (optional) -} - -// IsCreate reports whether the FileEvent was triggered by a creation -func (e *FileEvent) IsCreate() bool { return (e.mask & sys_FS_CREATE) == sys_FS_CREATE } - -// IsDelete reports whether the FileEvent was triggered by a delete -func (e *FileEvent) IsDelete() bool { - return ((e.mask&sys_FS_DELETE) == sys_FS_DELETE || (e.mask&sys_FS_DELETE_SELF) == sys_FS_DELETE_SELF) -} - -// IsModify reports whether the FileEvent was triggered by a file modification or attribute change -func (e *FileEvent) IsModify() bool { - return ((e.mask&sys_FS_MODIFY) == sys_FS_MODIFY || (e.mask&sys_FS_ATTRIB) == sys_FS_ATTRIB) -} - -// IsRename reports whether the FileEvent was triggered by a change name -func (e *FileEvent) IsRename() bool { - return ((e.mask&sys_FS_MOVE) == sys_FS_MOVE || (e.mask&sys_FS_MOVE_SELF) == sys_FS_MOVE_SELF || (e.mask&sys_FS_MOVED_FROM) == sys_FS_MOVED_FROM || (e.mask&sys_FS_MOVED_TO) == sys_FS_MOVED_TO) -} - -// IsAttrib reports whether the FileEvent was triggered by a change in the file metadata. -func (e *FileEvent) IsAttrib() bool { - return (e.mask & sys_FS_ATTRIB) == sys_FS_ATTRIB -} - -const ( - opAddWatch = iota - opRemoveWatch -) - -const ( - provisional uint64 = 1 << (32 + iota) -) - -type input struct { - op int - path string - flags uint32 - reply chan error -} - -type inode struct { - handle syscall.Handle - volume uint32 - index uint64 -} - -type watch struct { - ov syscall.Overlapped - ino *inode // i-number - path string // Directory path - mask uint64 // Directory itself is being watched with these notify flags - names map[string]uint64 // Map of names being watched and their notify flags - rename string // Remembers the old name while renaming a file - buf [4096]byte -} - -type indexMap map[uint64]*watch -type watchMap map[uint32]indexMap - -// A Watcher waits for and receives event notifications -// for a specific set of files and directories. -type Watcher struct { - mu sync.Mutex // Map access - port syscall.Handle // Handle to completion port - watches watchMap // Map of watches (key: i-number) - fsnFlags map[string]uint32 // Map of watched files to flags used for filter - fsnmut sync.Mutex // Protects access to fsnFlags. - input chan *input // Inputs to the reader are sent on this channel - internalEvent chan *FileEvent // Events are queued on this channel - Event chan *FileEvent // Events are returned on this channel - Error chan error // Errors are sent on this channel - isClosed bool // Set to true when Close() is first called - quit chan chan<- error - cookie uint32 -} - -// NewWatcher creates and returns a Watcher. -func NewWatcher() (*Watcher, error) { - port, e := syscall.CreateIoCompletionPort(syscall.InvalidHandle, 0, 0, 0) - if e != nil { - return nil, os.NewSyscallError("CreateIoCompletionPort", e) - } - w := &Watcher{ - port: port, - watches: make(watchMap), - fsnFlags: make(map[string]uint32), - input: make(chan *input, 1), - Event: make(chan *FileEvent, 50), - internalEvent: make(chan *FileEvent), - Error: make(chan error), - quit: make(chan chan<- error, 1), - } - go w.readEvents() - go w.purgeEvents() - return w, nil -} - -// Close closes a Watcher. -// It sends a message to the reader goroutine to quit and removes all watches -// associated with the watcher. -func (w *Watcher) Close() error { - if w.isClosed { - return nil - } - w.isClosed = true - - // Send "quit" message to the reader goroutine - ch := make(chan error) - w.quit <- ch - if err := w.wakeupReader(); err != nil { - return err - } - return <-ch -} - -// AddWatch adds path to the watched file set. -func (w *Watcher) AddWatch(path string, flags uint32) error { - if w.isClosed { - return errors.New("watcher already closed") - } - in := &input{ - op: opAddWatch, - path: filepath.Clean(path), - flags: flags, - reply: make(chan error), - } - w.input <- in - if err := w.wakeupReader(); err != nil { - return err - } - return <-in.reply -} - -// Watch adds path to the watched file set, watching all events. -func (w *Watcher) watch(path string) error { - return w.AddWatch(path, sys_FS_ALL_EVENTS) -} - -// RemoveWatch removes path from the watched file set. -func (w *Watcher) removeWatch(path string) error { - in := &input{ - op: opRemoveWatch, - path: filepath.Clean(path), - reply: make(chan error), - } - w.input <- in - if err := w.wakeupReader(); err != nil { - return err - } - return <-in.reply -} - -func (w *Watcher) wakeupReader() error { - e := syscall.PostQueuedCompletionStatus(w.port, 0, 0, nil) - if e != nil { - return os.NewSyscallError("PostQueuedCompletionStatus", e) - } - return nil -} - -func getDir(pathname string) (dir string, err error) { - attr, e := syscall.GetFileAttributes(syscall.StringToUTF16Ptr(pathname)) - if e != nil { - return "", os.NewSyscallError("GetFileAttributes", e) - } - if attr&syscall.FILE_ATTRIBUTE_DIRECTORY != 0 { - dir = pathname - } else { - dir, _ = filepath.Split(pathname) - dir = filepath.Clean(dir) - } - return -} - -func getIno(path string) (ino *inode, err error) { - h, e := syscall.CreateFile(syscall.StringToUTF16Ptr(path), - syscall.FILE_LIST_DIRECTORY, - syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE, - nil, syscall.OPEN_EXISTING, - syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OVERLAPPED, 0) - if e != nil { - return nil, os.NewSyscallError("CreateFile", e) - } - var fi syscall.ByHandleFileInformation - if e = syscall.GetFileInformationByHandle(h, &fi); e != nil { - syscall.CloseHandle(h) - return nil, os.NewSyscallError("GetFileInformationByHandle", e) - } - ino = &inode{ - handle: h, - volume: fi.VolumeSerialNumber, - index: uint64(fi.FileIndexHigh)<<32 | uint64(fi.FileIndexLow), - } - return ino, nil -} - -// Must run within the I/O thread. -func (m watchMap) get(ino *inode) *watch { - if i := m[ino.volume]; i != nil { - return i[ino.index] - } - return nil -} - -// Must run within the I/O thread. -func (m watchMap) set(ino *inode, watch *watch) { - i := m[ino.volume] - if i == nil { - i = make(indexMap) - m[ino.volume] = i - } - i[ino.index] = watch -} - -// Must run within the I/O thread. -func (w *Watcher) addWatch(pathname string, flags uint64) error { - dir, err := getDir(pathname) - if err != nil { - return err - } - if flags&sys_FS_ONLYDIR != 0 && pathname != dir { - return nil - } - ino, err := getIno(dir) - if err != nil { - return err - } - w.mu.Lock() - watchEntry := w.watches.get(ino) - w.mu.Unlock() - if watchEntry == nil { - if _, e := syscall.CreateIoCompletionPort(ino.handle, w.port, 0, 0); e != nil { - syscall.CloseHandle(ino.handle) - return os.NewSyscallError("CreateIoCompletionPort", e) - } - watchEntry = &watch{ - ino: ino, - path: dir, - names: make(map[string]uint64), - } - w.mu.Lock() - w.watches.set(ino, watchEntry) - w.mu.Unlock() - flags |= provisional - } else { - syscall.CloseHandle(ino.handle) - } - if pathname == dir { - watchEntry.mask |= flags - } else { - watchEntry.names[filepath.Base(pathname)] |= flags - } - if err = w.startRead(watchEntry); err != nil { - return err - } - if pathname == dir { - watchEntry.mask &= ^provisional - } else { - watchEntry.names[filepath.Base(pathname)] &= ^provisional - } - return nil -} - -// Must run within the I/O thread. -func (w *Watcher) remWatch(pathname string) error { - dir, err := getDir(pathname) - if err != nil { - return err - } - ino, err := getIno(dir) - if err != nil { - return err - } - w.mu.Lock() - watch := w.watches.get(ino) - w.mu.Unlock() - if watch == nil { - return fmt.Errorf("can't remove non-existent watch for: %s", pathname) - } - if pathname == dir { - w.sendEvent(watch.path, watch.mask&sys_FS_IGNORED) - watch.mask = 0 - } else { - name := filepath.Base(pathname) - w.sendEvent(watch.path+"\\"+name, watch.names[name]&sys_FS_IGNORED) - delete(watch.names, name) - } - return w.startRead(watch) -} - -// Must run within the I/O thread. -func (w *Watcher) deleteWatch(watch *watch) { - for name, mask := range watch.names { - if mask&provisional == 0 { - w.sendEvent(watch.path+"\\"+name, mask&sys_FS_IGNORED) - } - delete(watch.names, name) - } - if watch.mask != 0 { - if watch.mask&provisional == 0 { - w.sendEvent(watch.path, watch.mask&sys_FS_IGNORED) - } - watch.mask = 0 - } -} - -// Must run within the I/O thread. -func (w *Watcher) startRead(watch *watch) error { - if e := syscall.CancelIo(watch.ino.handle); e != nil { - w.Error <- os.NewSyscallError("CancelIo", e) - w.deleteWatch(watch) - } - mask := toWindowsFlags(watch.mask) - for _, m := range watch.names { - mask |= toWindowsFlags(m) - } - if mask == 0 { - if e := syscall.CloseHandle(watch.ino.handle); e != nil { - w.Error <- os.NewSyscallError("CloseHandle", e) - } - w.mu.Lock() - delete(w.watches[watch.ino.volume], watch.ino.index) - w.mu.Unlock() - return nil - } - e := syscall.ReadDirectoryChanges(watch.ino.handle, &watch.buf[0], - uint32(unsafe.Sizeof(watch.buf)), false, mask, nil, &watch.ov, 0) - if e != nil { - err := os.NewSyscallError("ReadDirectoryChanges", e) - if e == syscall.ERROR_ACCESS_DENIED && watch.mask&provisional == 0 { - // Watched directory was probably removed - if w.sendEvent(watch.path, watch.mask&sys_FS_DELETE_SELF) { - if watch.mask&sys_FS_ONESHOT != 0 { - watch.mask = 0 - } - } - err = nil - } - w.deleteWatch(watch) - w.startRead(watch) - return err - } - return nil -} - -// readEvents reads from the I/O completion port, converts the -// received events into Event objects and sends them via the Event channel. -// Entry point to the I/O thread. -func (w *Watcher) readEvents() { - var ( - n, key uint32 - ov *syscall.Overlapped - ) - runtime.LockOSThread() - - for { - e := syscall.GetQueuedCompletionStatus(w.port, &n, &key, &ov, syscall.INFINITE) - watch := (*watch)(unsafe.Pointer(ov)) - - if watch == nil { - select { - case ch := <-w.quit: - w.mu.Lock() - var indexes []indexMap - for _, index := range w.watches { - indexes = append(indexes, index) - } - w.mu.Unlock() - for _, index := range indexes { - for _, watch := range index { - w.deleteWatch(watch) - w.startRead(watch) - } - } - var err error - if e := syscall.CloseHandle(w.port); e != nil { - err = os.NewSyscallError("CloseHandle", e) - } - close(w.internalEvent) - close(w.Error) - ch <- err - return - case in := <-w.input: - switch in.op { - case opAddWatch: - in.reply <- w.addWatch(in.path, uint64(in.flags)) - case opRemoveWatch: - in.reply <- w.remWatch(in.path) - } - default: - } - continue - } - - switch e { - case sys_ERROR_MORE_DATA: - if watch == nil { - w.Error <- errors.New("ERROR_MORE_DATA has unexpectedly null lpOverlapped buffer") - } else { - // The i/o succeeded but the buffer is full. - // In theory we should be building up a full packet. - // In practice we can get away with just carrying on. - n = uint32(unsafe.Sizeof(watch.buf)) - } - case syscall.ERROR_ACCESS_DENIED: - // Watched directory was probably removed - w.sendEvent(watch.path, watch.mask&sys_FS_DELETE_SELF) - w.deleteWatch(watch) - w.startRead(watch) - continue - case syscall.ERROR_OPERATION_ABORTED: - // CancelIo was called on this handle - continue - default: - w.Error <- os.NewSyscallError("GetQueuedCompletionPort", e) - continue - case nil: - } - - var offset uint32 - for { - if n == 0 { - w.internalEvent <- &FileEvent{mask: sys_FS_Q_OVERFLOW} - w.Error <- errors.New("short read in readEvents()") - break - } - - // Point "raw" to the event in the buffer - raw := (*syscall.FileNotifyInformation)(unsafe.Pointer(&watch.buf[offset])) - buf := (*[syscall.MAX_PATH]uint16)(unsafe.Pointer(&raw.FileName)) - name := syscall.UTF16ToString(buf[:raw.FileNameLength/2]) - fullname := watch.path + "\\" + name - - var mask uint64 - switch raw.Action { - case syscall.FILE_ACTION_REMOVED: - mask = sys_FS_DELETE_SELF - case syscall.FILE_ACTION_MODIFIED: - mask = sys_FS_MODIFY - case syscall.FILE_ACTION_RENAMED_OLD_NAME: - watch.rename = name - case syscall.FILE_ACTION_RENAMED_NEW_NAME: - if watch.names[watch.rename] != 0 { - watch.names[name] |= watch.names[watch.rename] - delete(watch.names, watch.rename) - mask = sys_FS_MOVE_SELF - } - } - - sendNameEvent := func() { - if w.sendEvent(fullname, watch.names[name]&mask) { - if watch.names[name]&sys_FS_ONESHOT != 0 { - delete(watch.names, name) - } - } - } - if raw.Action != syscall.FILE_ACTION_RENAMED_NEW_NAME { - sendNameEvent() - } - if raw.Action == syscall.FILE_ACTION_REMOVED { - w.sendEvent(fullname, watch.names[name]&sys_FS_IGNORED) - delete(watch.names, name) - } - if w.sendEvent(fullname, watch.mask&toFSnotifyFlags(raw.Action)) { - if watch.mask&sys_FS_ONESHOT != 0 { - watch.mask = 0 - } - } - if raw.Action == syscall.FILE_ACTION_RENAMED_NEW_NAME { - fullname = watch.path + "\\" + watch.rename - sendNameEvent() - } - - // Move to the next event in the buffer - if raw.NextEntryOffset == 0 { - break - } - offset += raw.NextEntryOffset - - // Error! - if offset >= n { - w.Error <- errors.New("Windows system assumed buffer larger than it is, events have likely been missed.") - break - } - } - - if err := w.startRead(watch); err != nil { - w.Error <- err - } - } -} - -func (w *Watcher) sendEvent(name string, mask uint64) bool { - if mask == 0 { - return false - } - event := &FileEvent{mask: uint32(mask), Name: name} - if mask&sys_FS_MOVE != 0 { - if mask&sys_FS_MOVED_FROM != 0 { - w.cookie++ - } - event.cookie = w.cookie - } - select { - case ch := <-w.quit: - w.quit <- ch - case w.Event <- event: - } - return true -} - -func toWindowsFlags(mask uint64) uint32 { - var m uint32 - if mask&sys_FS_ACCESS != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS - } - if mask&sys_FS_MODIFY != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_LAST_WRITE - } - if mask&sys_FS_ATTRIB != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES - } - if mask&(sys_FS_MOVE|sys_FS_CREATE|sys_FS_DELETE) != 0 { - m |= syscall.FILE_NOTIFY_CHANGE_FILE_NAME | syscall.FILE_NOTIFY_CHANGE_DIR_NAME - } - return m -} - -func toFSnotifyFlags(action uint32) uint64 { - switch action { - case syscall.FILE_ACTION_ADDED: - return sys_FS_CREATE - case syscall.FILE_ACTION_REMOVED: - return sys_FS_DELETE - case syscall.FILE_ACTION_MODIFIED: - return sys_FS_MODIFY - case syscall.FILE_ACTION_RENAMED_OLD_NAME: - return sys_FS_MOVED_FROM - case syscall.FILE_ACTION_RENAMED_NEW_NAME: - return sys_FS_MOVED_TO - } - return 0 -} diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/.travis.yml b/Godeps/_workspace/src/github.com/mattn/go-runewidth/.travis.yml new file mode 100644 index 000000000..ad584f4da --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/.travis.yml @@ -0,0 +1,9 @@ +language: go +go: + - tip +before_install: + - go get github.com/axw/gocov/gocov + - go get github.com/mattn/goveralls + - go get golang.org/x/tools/cmd/cover +script: + - $HOME/gopath/bin/goveralls -repotoken lAKAWPzcGsD3A8yBX3BGGtRUdJ6CaGERL diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/README.mkd b/Godeps/_workspace/src/github.com/mattn/go-runewidth/README.mkd new file mode 100644 index 000000000..4f0d583be --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/README.mkd @@ -0,0 +1,25 @@ +go-runewidth +============ + +[![Build Status](https://travis-ci.org/mattn/go-runewidth.png?branch=master)](https://travis-ci.org/mattn/go-runewidth) +[![Coverage Status](https://coveralls.io/repos/mattn/go-runewidth/badge.png?branch=HEAD)](https://coveralls.io/r/mattn/go-runewidth?branch=HEAD) + +Provides functions to get fixed width of the character or string. + +Usage +----- + +```go +runewidth.StringWidth("つのだ☆HIRO") == 12 +``` + + +Author +------ + +Yasuhiro Matsumoto + +License +------- + +under the MIT License: http://mattn.mit-license.org/2013 diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth.go b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth.go new file mode 100644 index 000000000..0b417db15 --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth.go @@ -0,0 +1,404 @@ +package runewidth + +var EastAsianWidth = IsEastAsian() +var DefaultCondition = &Condition{EastAsianWidth} + +type interval struct { + first rune + last rune +} + +var combining = []interval{ + {0x0300, 0x036F}, {0x0483, 0x0486}, {0x0488, 0x0489}, + {0x0591, 0x05BD}, {0x05BF, 0x05BF}, {0x05C1, 0x05C2}, + {0x05C4, 0x05C5}, {0x05C7, 0x05C7}, {0x0600, 0x0603}, + {0x0610, 0x0615}, {0x064B, 0x065E}, {0x0670, 0x0670}, + {0x06D6, 0x06E4}, {0x06E7, 0x06E8}, {0x06EA, 0x06ED}, + {0x070F, 0x070F}, {0x0711, 0x0711}, {0x0730, 0x074A}, + {0x07A6, 0x07B0}, {0x07EB, 0x07F3}, {0x0901, 0x0902}, + {0x093C, 0x093C}, {0x0941, 0x0948}, {0x094D, 0x094D}, + {0x0951, 0x0954}, {0x0962, 0x0963}, {0x0981, 0x0981}, + {0x09BC, 0x09BC}, {0x09C1, 0x09C4}, {0x09CD, 0x09CD}, + {0x09E2, 0x09E3}, {0x0A01, 0x0A02}, {0x0A3C, 0x0A3C}, + {0x0A41, 0x0A42}, {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, + {0x0A70, 0x0A71}, {0x0A81, 0x0A82}, {0x0ABC, 0x0ABC}, + {0x0AC1, 0x0AC5}, {0x0AC7, 0x0AC8}, {0x0ACD, 0x0ACD}, + {0x0AE2, 0x0AE3}, {0x0B01, 0x0B01}, {0x0B3C, 0x0B3C}, + {0x0B3F, 0x0B3F}, {0x0B41, 0x0B43}, {0x0B4D, 0x0B4D}, + {0x0B56, 0x0B56}, {0x0B82, 0x0B82}, {0x0BC0, 0x0BC0}, + {0x0BCD, 0x0BCD}, {0x0C3E, 0x0C40}, {0x0C46, 0x0C48}, + {0x0C4A, 0x0C4D}, {0x0C55, 0x0C56}, {0x0CBC, 0x0CBC}, + {0x0CBF, 0x0CBF}, {0x0CC6, 0x0CC6}, {0x0CCC, 0x0CCD}, + {0x0CE2, 0x0CE3}, {0x0D41, 0x0D43}, {0x0D4D, 0x0D4D}, + {0x0DCA, 0x0DCA}, {0x0DD2, 0x0DD4}, {0x0DD6, 0x0DD6}, + {0x0E31, 0x0E31}, {0x0E34, 0x0E3A}, {0x0E47, 0x0E4E}, + {0x0EB1, 0x0EB1}, {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC}, + {0x0EC8, 0x0ECD}, {0x0F18, 0x0F19}, {0x0F35, 0x0F35}, + {0x0F37, 0x0F37}, {0x0F39, 0x0F39}, {0x0F71, 0x0F7E}, + {0x0F80, 0x0F84}, {0x0F86, 0x0F87}, {0x0F90, 0x0F97}, + {0x0F99, 0x0FBC}, {0x0FC6, 0x0FC6}, {0x102D, 0x1030}, + {0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039}, + {0x1058, 0x1059}, {0x1160, 0x11FF}, {0x135F, 0x135F}, + {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753}, + {0x1772, 0x1773}, {0x17B4, 0x17B5}, {0x17B7, 0x17BD}, + {0x17C6, 0x17C6}, {0x17C9, 0x17D3}, {0x17DD, 0x17DD}, + {0x180B, 0x180D}, {0x18A9, 0x18A9}, {0x1920, 0x1922}, + {0x1927, 0x1928}, {0x1932, 0x1932}, {0x1939, 0x193B}, + {0x1A17, 0x1A18}, {0x1B00, 0x1B03}, {0x1B34, 0x1B34}, + {0x1B36, 0x1B3A}, {0x1B3C, 0x1B3C}, {0x1B42, 0x1B42}, + {0x1B6B, 0x1B73}, {0x1DC0, 0x1DCA}, {0x1DFE, 0x1DFF}, + {0x200B, 0x200F}, {0x202A, 0x202E}, {0x2060, 0x2063}, + {0x206A, 0x206F}, {0x20D0, 0x20EF}, {0x302A, 0x302F}, + {0x3099, 0x309A}, {0xA806, 0xA806}, {0xA80B, 0xA80B}, + {0xA825, 0xA826}, {0xFB1E, 0xFB1E}, {0xFE00, 0xFE0F}, + {0xFE20, 0xFE23}, {0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFB}, + {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F}, + {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x1D167, 0x1D169}, + {0x1D173, 0x1D182}, {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD}, + {0x1D242, 0x1D244}, {0xE0001, 0xE0001}, {0xE0020, 0xE007F}, + {0xE0100, 0xE01EF}, +} + +type ctype int + +const ( + narrow ctype = iota + ambiguous + wide + halfwidth + fullwidth + neutral +) + +type intervalType struct { + first rune + last rune + ctype ctype +} + +var ctypes = []intervalType{ + {0x0020, 0x007E, narrow}, + {0x00A1, 0x00A1, ambiguous}, + {0x00A2, 0x00A3, narrow}, + {0x00A4, 0x00A4, ambiguous}, + {0x00A5, 0x00A6, narrow}, + {0x00A7, 0x00A8, ambiguous}, + {0x00AA, 0x00AA, ambiguous}, + {0x00AC, 0x00AC, narrow}, + {0x00AD, 0x00AE, ambiguous}, + {0x00AF, 0x00AF, narrow}, + {0x00B0, 0x00B4, ambiguous}, + {0x00B6, 0x00BA, ambiguous}, + {0x00BC, 0x00BF, ambiguous}, + {0x00C6, 0x00C6, ambiguous}, + {0x00D0, 0x00D0, ambiguous}, + {0x00D7, 0x00D8, ambiguous}, + {0x00DE, 0x00E1, ambiguous}, + {0x00E6, 0x00E6, ambiguous}, + {0x00E8, 0x00EA, ambiguous}, + {0x00EC, 0x00ED, ambiguous}, + {0x00F0, 0x00F0, ambiguous}, + {0x00F2, 0x00F3, ambiguous}, + {0x00F7, 0x00FA, ambiguous}, + {0x00FC, 0x00FC, ambiguous}, + {0x00FE, 0x00FE, ambiguous}, + {0x0101, 0x0101, ambiguous}, + {0x0111, 0x0111, ambiguous}, + {0x0113, 0x0113, ambiguous}, + {0x011B, 0x011B, ambiguous}, + {0x0126, 0x0127, ambiguous}, + {0x012B, 0x012B, ambiguous}, + {0x0131, 0x0133, ambiguous}, + {0x0138, 0x0138, ambiguous}, + {0x013F, 0x0142, ambiguous}, + {0x0144, 0x0144, ambiguous}, + {0x0148, 0x014B, ambiguous}, + {0x014D, 0x014D, ambiguous}, + {0x0152, 0x0153, ambiguous}, + {0x0166, 0x0167, ambiguous}, + {0x016B, 0x016B, ambiguous}, + {0x01CE, 0x01CE, ambiguous}, + {0x01D0, 0x01D0, ambiguous}, + {0x01D2, 0x01D2, ambiguous}, + {0x01D4, 0x01D4, ambiguous}, + {0x01D6, 0x01D6, ambiguous}, + {0x01D8, 0x01D8, ambiguous}, + {0x01DA, 0x01DA, ambiguous}, + {0x01DC, 0x01DC, ambiguous}, + {0x0251, 0x0251, ambiguous}, + {0x0261, 0x0261, ambiguous}, + {0x02C4, 0x02C4, ambiguous}, + {0x02C7, 0x02C7, ambiguous}, + {0x02C9, 0x02CB, ambiguous}, + {0x02CD, 0x02CD, ambiguous}, + {0x02D0, 0x02D0, ambiguous}, + {0x02D8, 0x02DB, ambiguous}, + {0x02DD, 0x02DD, ambiguous}, + {0x02DF, 0x02DF, ambiguous}, + {0x0300, 0x036F, ambiguous}, + {0x0391, 0x03A2, ambiguous}, + {0x03A3, 0x03A9, ambiguous}, + {0x03B1, 0x03C1, ambiguous}, + {0x03C3, 0x03C9, ambiguous}, + {0x0401, 0x0401, ambiguous}, + {0x0410, 0x044F, ambiguous}, + {0x0451, 0x0451, ambiguous}, + {0x1100, 0x115F, wide}, + {0x2010, 0x2010, ambiguous}, + {0x2013, 0x2016, ambiguous}, + {0x2018, 0x2019, ambiguous}, + {0x201C, 0x201D, ambiguous}, + {0x2020, 0x2022, ambiguous}, + {0x2024, 0x2027, ambiguous}, + {0x2030, 0x2030, ambiguous}, + {0x2032, 0x2033, ambiguous}, + {0x2035, 0x2035, ambiguous}, + {0x203B, 0x203B, ambiguous}, + {0x203E, 0x203E, ambiguous}, + {0x2074, 0x2074, ambiguous}, + {0x207F, 0x207F, ambiguous}, + {0x2081, 0x2084, ambiguous}, + {0x20A9, 0x20A9, halfwidth}, + {0x20AC, 0x20AC, ambiguous}, + {0x2103, 0x2103, ambiguous}, + {0x2105, 0x2105, ambiguous}, + {0x2109, 0x2109, ambiguous}, + {0x2113, 0x2113, ambiguous}, + {0x2116, 0x2116, ambiguous}, + {0x2121, 0x2122, ambiguous}, + {0x2126, 0x2126, ambiguous}, + {0x212B, 0x212B, ambiguous}, + {0x2153, 0x2154, ambiguous}, + {0x215B, 0x215E, ambiguous}, + {0x2160, 0x216B, ambiguous}, + {0x2170, 0x2179, ambiguous}, + {0x2189, 0x218A, ambiguous}, + {0x2190, 0x2199, ambiguous}, + {0x21B8, 0x21B9, ambiguous}, + {0x21D2, 0x21D2, ambiguous}, + {0x21D4, 0x21D4, ambiguous}, + {0x21E7, 0x21E7, ambiguous}, + {0x2200, 0x2200, ambiguous}, + {0x2202, 0x2203, ambiguous}, + {0x2207, 0x2208, ambiguous}, + {0x220B, 0x220B, ambiguous}, + {0x220F, 0x220F, ambiguous}, + {0x2211, 0x2211, ambiguous}, + {0x2215, 0x2215, ambiguous}, + {0x221A, 0x221A, ambiguous}, + {0x221D, 0x2220, ambiguous}, + {0x2223, 0x2223, ambiguous}, + {0x2225, 0x2225, ambiguous}, + {0x2227, 0x222C, ambiguous}, + {0x222E, 0x222E, ambiguous}, + {0x2234, 0x2237, ambiguous}, + {0x223C, 0x223D, ambiguous}, + {0x2248, 0x2248, ambiguous}, + {0x224C, 0x224C, ambiguous}, + {0x2252, 0x2252, ambiguous}, + {0x2260, 0x2261, ambiguous}, + {0x2264, 0x2267, ambiguous}, + {0x226A, 0x226B, ambiguous}, + {0x226E, 0x226F, ambiguous}, + {0x2282, 0x2283, ambiguous}, + {0x2286, 0x2287, ambiguous}, + {0x2295, 0x2295, ambiguous}, + {0x2299, 0x2299, ambiguous}, + {0x22A5, 0x22A5, ambiguous}, + {0x22BF, 0x22BF, ambiguous}, + {0x2312, 0x2312, ambiguous}, + {0x2329, 0x232A, wide}, + {0x2460, 0x24E9, ambiguous}, + {0x24EB, 0x254B, ambiguous}, + {0x2550, 0x2573, ambiguous}, + {0x2580, 0x258F, ambiguous}, + {0x2592, 0x2595, ambiguous}, + {0x25A0, 0x25A1, ambiguous}, + {0x25A3, 0x25A9, ambiguous}, + {0x25B2, 0x25B3, ambiguous}, + {0x25B6, 0x25B7, ambiguous}, + {0x25BC, 0x25BD, ambiguous}, + {0x25C0, 0x25C1, ambiguous}, + {0x25C6, 0x25C8, ambiguous}, + {0x25CB, 0x25CB, ambiguous}, + {0x25CE, 0x25D1, ambiguous}, + {0x25E2, 0x25E5, ambiguous}, + {0x25EF, 0x25EF, ambiguous}, + {0x2605, 0x2606, ambiguous}, + {0x2609, 0x2609, ambiguous}, + {0x260E, 0x260F, ambiguous}, + {0x2614, 0x2615, ambiguous}, + {0x261C, 0x261C, ambiguous}, + {0x261E, 0x261E, ambiguous}, + {0x2640, 0x2640, ambiguous}, + {0x2642, 0x2642, ambiguous}, + {0x2660, 0x2661, ambiguous}, + {0x2663, 0x2665, ambiguous}, + {0x2667, 0x266A, ambiguous}, + {0x266C, 0x266D, ambiguous}, + {0x266F, 0x266F, ambiguous}, + {0x269E, 0x269F, ambiguous}, + {0x26BE, 0x26BF, ambiguous}, + {0x26C4, 0x26CD, ambiguous}, + {0x26CF, 0x26E1, ambiguous}, + {0x26E3, 0x26E3, ambiguous}, + {0x26E8, 0x26FF, ambiguous}, + {0x273D, 0x273D, ambiguous}, + {0x2757, 0x2757, ambiguous}, + {0x2776, 0x277F, ambiguous}, + {0x27E6, 0x27ED, narrow}, + {0x2985, 0x2986, narrow}, + {0x2B55, 0x2B59, ambiguous}, + {0x2E80, 0x2E9A, wide}, + {0x2E9B, 0x2EF4, wide}, + {0x2F00, 0x2FD6, wide}, + {0x2FF0, 0x2FFC, wide}, + {0x3000, 0x3000, fullwidth}, + {0x3001, 0x303E, wide}, + {0x3041, 0x3097, wide}, + {0x3099, 0x3100, wide}, + {0x3105, 0x312E, wide}, + {0x3131, 0x318F, wide}, + {0x3190, 0x31BB, wide}, + {0x31C0, 0x31E4, wide}, + {0x31F0, 0x321F, wide}, + {0x3220, 0x3247, wide}, + {0x3248, 0x324F, ambiguous}, + {0x3250, 0x32FF, wide}, + {0x3300, 0x4DBF, wide}, + {0x4E00, 0xA48D, wide}, + {0xA490, 0xA4C7, wide}, + {0xA960, 0xA97D, wide}, + {0xAC00, 0xD7A4, wide}, + {0xE000, 0xF8FF, ambiguous}, + {0xF900, 0xFAFF, wide}, + {0xFE00, 0xFE0F, ambiguous}, + {0xFE10, 0xFE1A, wide}, + {0xFE30, 0xFE53, wide}, + {0xFE54, 0xFE67, wide}, + {0xFE68, 0xFE6C, wide}, + {0xFF01, 0xFF60, fullwidth}, + {0xFF61, 0xFFBF, halfwidth}, + {0xFFC2, 0xFFC8, halfwidth}, + {0xFFCA, 0xFFD0, halfwidth}, + {0xFFD2, 0xFFD8, halfwidth}, + {0xFFDA, 0xFFDD, halfwidth}, + {0xFFE0, 0xFFE7, fullwidth}, + {0xFFE8, 0xFFEF, halfwidth}, + {0xFFFD, 0xFFFE, ambiguous}, + {0x1B000, 0x1B002, wide}, + {0x1F100, 0x1F10A, ambiguous}, + {0x1F110, 0x1F12D, ambiguous}, + {0x1F130, 0x1F169, ambiguous}, + {0x1F170, 0x1F19B, ambiguous}, + {0x1F200, 0x1F203, wide}, + {0x1F210, 0x1F23B, wide}, + {0x1F240, 0x1F249, wide}, + {0x1F250, 0x1F252, wide}, + {0x20000, 0x2FFFE, wide}, + {0x30000, 0x3FFFE, wide}, + {0xE0100, 0xE01F0, ambiguous}, + {0xF0000, 0xFFFFD, ambiguous}, + {0x100000, 0x10FFFE, ambiguous}, +} + +type Condition struct { + EastAsianWidth bool +} + +func NewCondition() *Condition { + return &Condition{EastAsianWidth} +} + +// RuneWidth returns the number of cells in r. +// See http://www.unicode.org/reports/tr11/ +func (c *Condition) RuneWidth(r rune) int { + if r == 0 { + return 0 + } + if r < 32 || (r >= 0x7f && r < 0xa0) { + return 1 + } + for _, iv := range combining { + if iv.first <= r && r <= iv.last { + return 0 + } + } + + if c.EastAsianWidth && IsAmbiguousWidth(r) { + return 2 + } + + if r >= 0x1100 && + (r <= 0x115f || r == 0x2329 || r == 0x232a || + (r >= 0x2e80 && r <= 0xa4cf && r != 0x303f) || + (r >= 0xac00 && r <= 0xd7a3) || + (r >= 0xf900 && r <= 0xfaff) || + (r >= 0xfe30 && r <= 0xfe6f) || + (r >= 0xff00 && r <= 0xff60) || + (r >= 0xffe0 && r <= 0xffe6) || + (r >= 0x20000 && r <= 0x2fffd) || + (r >= 0x30000 && r <= 0x3fffd)) { + return 2 + } + return 1 +} + +func (c *Condition) StringWidth(s string) (width int) { + for _, r := range []rune(s) { + width += c.RuneWidth(r) + } + return width +} + +func (c *Condition) Truncate(s string, w int, tail string) string { + r := []rune(s) + tw := StringWidth(tail) + w -= tw + width := 0 + i := 0 + for ; i < len(r); i++ { + cw := RuneWidth(r[i]) + if width+cw > w { + break + } + width += cw + } + if i == len(r) { + return string(r[0:i]) + } + return string(r[0:i]) + tail +} + +// RuneWidth returns the number of cells in r. +// See http://www.unicode.org/reports/tr11/ +func RuneWidth(r rune) int { + return DefaultCondition.RuneWidth(r) +} + +func ct(r rune) ctype { + for _, iv := range ctypes { + if iv.first <= r && r <= iv.last { + return iv.ctype + } + } + return neutral +} + +// IsAmbiguousWidth returns whether is ambiguous width or not. +func IsAmbiguousWidth(r rune) bool { + return ct(r) == ambiguous +} + +// IsAmbiguousWidth returns whether is ambiguous width or not. +func IsNeutralWidth(r rune) bool { + return ct(r) == neutral +} + +func StringWidth(s string) (width int) { + return DefaultCondition.StringWidth(s) +} + +func Truncate(s string, w int, tail string) string { + return DefaultCondition.Truncate(s, w, tail) +} diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_js.go b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_js.go new file mode 100644 index 000000000..0ce32c5e7 --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_js.go @@ -0,0 +1,8 @@ +// +build js + +package runewidth + +func IsEastAsian() bool { + // TODO: Implement this for the web. Detect east asian in a compatible way, and return true. + return false +} diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_posix.go b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_posix.go new file mode 100644 index 000000000..a4495909d --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_posix.go @@ -0,0 +1,69 @@ +// +build !windows,!js + +package runewidth + +import ( + "os" + "regexp" + "strings" +) + +var reLoc = regexp.MustCompile(`^[a-z][a-z][a-z]?(?:_[A-Z][A-Z])?\.(.+)`) + +func IsEastAsian() bool { + locale := os.Getenv("LC_CTYPE") + if locale == "" { + locale = os.Getenv("LANG") + } + + // ignore C locale + if locale == "POSIX" || locale == "C" { + return false + } + if len(locale) > 1 && locale[0] == 'C' && (locale[1] == '.' || locale[1] == '-') { + return false + } + + charset := strings.ToLower(locale) + r := reLoc.FindStringSubmatch(locale) + if len(r) == 2 { + charset = strings.ToLower(r[1]) + } + + if strings.HasSuffix(charset, "@cjk_narrow") { + return false + } + + for pos, b := range []byte(charset) { + if b == '@' { + charset = charset[:pos] + break + } + } + + mbc_max := 1 + switch charset { + case "utf-8", "utf8": + mbc_max = 6 + case "jis": + mbc_max = 8 + case "eucjp": + mbc_max = 3 + case "euckr", "euccn": + mbc_max = 2 + case "sjis", "cp932", "cp51932", "cp936", "cp949", "cp950": + mbc_max = 2 + case "big5": + mbc_max = 2 + case "gbk", "gb2312": + mbc_max = 2 + } + + if mbc_max > 1 && (charset[0] != 'u' || + strings.HasPrefix(locale, "ja") || + strings.HasPrefix(locale, "ko") || + strings.HasPrefix(locale, "zh")) { + return true + } + return false +} diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_test.go b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_test.go new file mode 100644 index 000000000..5cef3d6a4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_test.go @@ -0,0 +1,134 @@ +package runewidth + +import ( + "testing" +) + +var runewidthtests = []struct { + in rune + out int +}{ + {'世', 2}, + {'界', 2}, + {'ｾ', 1}, + {'ｶ', 1}, + {'ｲ', 1}, + {'☆', 2}, // double width in ambiguous + {'\x00', 0}, + {'\x01', 1}, + {'\u0300', 0}, +} + +func TestRuneWidth(t *testing.T) { + c := NewCondition() + c.EastAsianWidth = true + for _, tt := range runewidthtests { + if out := c.RuneWidth(tt.in); out != tt.out { + t.Errorf("Width(%q) = %v, want %v", tt.in, out, tt.out) + } + } +} + +var isambiguouswidthtests = []struct { + in rune + out bool +}{ + {'世', false}, + {'■', true}, + {'界', false}, + {'○', true}, + {'㈱', false}, + {'①', true}, + {'②', true}, + {'③', true}, + {'④', true}, + {'⑤', true}, + {'⑥', true}, + {'⑦', true}, + {'⑧', true}, + {'⑨', true}, + {'⑩', true}, + {'⑪', true}, + {'⑫', true}, + {'⑬', true}, + {'⑭', true}, + {'⑮', true}, + {'⑯', true}, + {'⑰', true}, + {'⑱', true}, + {'⑲', true}, + {'⑳', true}, + {'☆', true}, +} + +func TestIsAmbiguousWidth(t *testing.T) { + for _, tt := range isambiguouswidthtests { + if out := IsAmbiguousWidth(tt.in); out != tt.out { + t.Errorf("IsAmbiguousWidth(%q) = %v, want %v", tt.in, out, tt.out) + } + } +} + +var stringwidthtests = []struct { + in string + out int +}{ + {"■㈱の世界①", 12}, + {"スター☆", 8}, +} + +func TestStringWidth(t *testing.T) { + c := NewCondition() + c.EastAsianWidth = true + for _, tt := range stringwidthtests { + if out := c.StringWidth(tt.in); out != tt.out { + t.Errorf("StringWidth(%q) = %v, want %v", tt.in, out, tt.out) + } + } +} + +func TestStringWidthInvalid(t *testing.T) { + s := "こんにちわ\x00世界" + if out := StringWidth(s); out != 14 { + t.Errorf("StringWidth(%q) = %v, want %v", s, out, 14) + } +} + +func TestTruncate(t *testing.T) { + s := "あいうえおあいうえおえおおおおおおおおおおおおおおおおおおおおおおおおおおおおおお" + expected := "あいうえおあいうえおえおおおおおおおおおおおおおおおおおおおおおおおおおおお..." + + if out := Truncate(s, 80, "..."); out != expected { + t.Errorf("Truncate(%q) = %v, want %v", s, out, expected) + } +} + +func TestTruncateNoNeeded(t *testing.T) { + s := "あいうえおあい" + expected := "あいうえおあい" + + if out := Truncate(s, 80, "..."); out != expected { + t.Errorf("Truncate(%q) = %v, want %v", s, out, expected) + } +} + +var isneutralwidthtests = []struct { + in rune + out bool +}{ + {'→', false}, + {'┊', false}, + {'┈', false}, + {'～', false}, + {'└', false}, + {'⣀', true}, + {'⣀', true}, +} + +func TestIsNeutralWidth(t *testing.T) { + for _, tt := range isneutralwidthtests { + if out := IsNeutralWidth(tt.in); out != tt.out { + t.Errorf("IsNeutralWidth(%q) = %v, want %v", tt.in, out, tt.out) + } + } +} diff --git a/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_windows.go b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_windows.go new file mode 100644 index 000000000..bdd84454b --- /dev/null +++ b/Godeps/_workspace/src/github.com/mattn/go-runewidth/runewidth_windows.go @@ -0,0 +1,24 @@ +package runewidth + +import ( + "syscall" +) + +var ( + kernel32 = syscall.NewLazyDLL("kernel32") + procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP") +) + +func IsEastAsian() bool { + r1, _, _ := procGetConsoleOutputCP.Call() + if r1 == 0 { + return false + } + + switch int(r1) { + case 932, 51932, 936, 949, 950: + return true + } + + return false +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/AUTHORS b/Godeps/_workspace/src/github.com/nsf/termbox-go/AUTHORS new file mode 100644 index 000000000..fe26fb0fb --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/AUTHORS @@ -0,0 +1,4 @@ +# Please keep this file sorted. + +Georg Reinke +nsf diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/LICENSE b/Godeps/_workspace/src/github.com/nsf/termbox-go/LICENSE new file mode 100644 index 000000000..d9bc068ce --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/LICENSE @@ -0,0 +1,19 @@ +Copyright (C) 2012 termbox-go authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/README.md b/Godeps/_workspace/src/github.com/nsf/termbox-go/README.md new file mode 100644 index 000000000..334d75102 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/README.md @@ -0,0 +1,21 @@ +## Termbox +Termbox is a library that provides a minimalistic API which allows the programmer to write text-based user interfaces. The library is crossplatform and has both terminal-based implementations on *nix operating systems and a winapi console based implementation for windows operating systems. The basic idea is an abstraction of the greatest common subset of features available on all major terminals and other terminal-like APIs in a minimalistic fashion. Small API means it is easy to implement, test, maintain and learn it, that's what makes the termbox a distinct library in its area. + +### Installation +Install and update this go package with `go get -u github.com/nsf/termbox-go` + +### Examples +For examples of what can be done take a look at demos in the _demos directory. You can try them with go run: `go run _demos/keyboard.go` + +There are also some interesting projects using termbox-go: + - [godit](https://github.com/nsf/godit) is an emacsish lightweight text editor written using termbox. + - [gomatrix](https://github.com/GeertJohan/gomatrix) connects to The Matrix and displays its data streams in your terminal. + - [gotetris](https://github.com/jjinux/gotetris) is an implementation of Tetris. + - [sokoban-go](https://github.com/rn2dy/sokoban-go) is an implementation of sokoban game. + - [hecate](https://github.com/evanmiller/hecate) is a hex editor designed by Satan. + - [httopd](https://github.com/verdverm/httopd) is top for httpd logs. + - [mop](https://github.com/michaeldv/mop) is stock market tracker for hackers. + - [termui](https://github.com/gizak/termui) is a terminal dashboard. + +### API reference +[godoc.org/github.com/nsf/termbox-go](http://godoc.org/github.com/nsf/termbox-go) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/api.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/api.go new file mode 100644 index 000000000..b08bca61a --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/api.go @@ -0,0 +1,451 @@ +// +build !windows + +package termbox + +import "github.com/mattn/go-runewidth" +import "fmt" +import "os" +import "os/signal" +import "syscall" +import "runtime" + +// public API + +// Initializes termbox library. This function should be called before any other functions. +// After successful initialization, the library must be finalized using 'Close' function. +// +// Example usage: +// err := termbox.Init() +// if err != nil { +// panic(err) +// } +// defer termbox.Close() +func Init() error { + var err error + + out, err = os.OpenFile("/dev/tty", syscall.O_WRONLY, 0) + if err != nil { + return err + } + in, err = syscall.Open("/dev/tty", syscall.O_RDONLY, 0) + if err != nil { + return err + } + + err = setup_term() + if err != nil { + return fmt.Errorf("termbox: error while reading terminfo data: %v", err) + } + + signal.Notify(sigwinch, syscall.SIGWINCH) + signal.Notify(sigio, syscall.SIGIO) + + _, err = fcntl(in, syscall.F_SETFL, syscall.O_ASYNC|syscall.O_NONBLOCK) + if err != nil { + return err + } + _, err = fcntl(in, syscall.F_SETOWN, syscall.Getpid()) + if runtime.GOOS != "darwin" && err != nil { + return err + } + err = tcgetattr(out.Fd(), &orig_tios) + if err != nil { + return err + } + + tios := orig_tios + tios.Iflag &^= syscall_IGNBRK | syscall_BRKINT | syscall_PARMRK | + syscall_ISTRIP | syscall_INLCR | syscall_IGNCR | + syscall_ICRNL | syscall_IXON + tios.Oflag &^= syscall_OPOST + tios.Lflag &^= syscall_ECHO | syscall_ECHONL | syscall_ICANON | + syscall_ISIG | syscall_IEXTEN + tios.Cflag &^= syscall_CSIZE | syscall_PARENB + tios.Cflag |= syscall_CS8 + tios.Cc[syscall_VMIN] = 1 + tios.Cc[syscall_VTIME] = 0 + + err = tcsetattr(out.Fd(), &tios) + if err != nil { + return err + } + + out.WriteString(funcs[t_enter_ca]) + out.WriteString(funcs[t_enter_keypad]) + out.WriteString(funcs[t_hide_cursor]) + out.WriteString(funcs[t_clear_screen]) + + termw, termh = get_term_size(out.Fd()) + back_buffer.init(termw, termh) + front_buffer.init(termw, termh) + back_buffer.clear() + front_buffer.clear() + + go func() { + buf := make([]byte, 128) + for { + select { + case <-sigio: + for { + n, err := syscall.Read(in, buf) + if err == syscall.EAGAIN || err == syscall.EWOULDBLOCK { + break + } + select { + case input_comm <- input_event{buf[:n], err}: + ie := <-input_comm + buf = ie.data[:128] + case <-quit: + return + } + } + case <-quit: + return + } + } + }() + + IsInit = true + return nil +} + +// Interrupt an in-progress call to PollEvent by causing it to return +// EventInterrupt. Note that this function will block until the PollEvent +// function has successfully been interrupted. +func Interrupt() { + interrupt_comm <- struct{}{} +} + +// Finalizes termbox library, should be called after successful initialization +// when termbox's functionality isn't required anymore. +func Close() { + quit <- 1 + out.WriteString(funcs[t_show_cursor]) + out.WriteString(funcs[t_sgr0]) + out.WriteString(funcs[t_clear_screen]) + out.WriteString(funcs[t_exit_ca]) + out.WriteString(funcs[t_exit_keypad]) + out.WriteString(funcs[t_exit_mouse]) + tcsetattr(out.Fd(), &orig_tios) + + out.Close() + syscall.Close(in) + + // reset the state, so that on next Init() it will work again + termw = 0 + termh = 0 + input_mode = InputEsc + out = nil + in = 0 + lastfg = attr_invalid + lastbg = attr_invalid + lastx = coord_invalid + lasty = coord_invalid + cursor_x = cursor_hidden + cursor_y = cursor_hidden + foreground = ColorDefault + background = ColorDefault + IsInit = false +} + +// Synchronizes the internal back buffer with the terminal. +func Flush() error { + // invalidate cursor position + lastx = coord_invalid + lasty = coord_invalid + + update_size_maybe() + + for y := 0; y < front_buffer.height; y++ { + line_offset := y * front_buffer.width + for x := 0; x < front_buffer.width; { + cell_offset := line_offset + x + back := &back_buffer.cells[cell_offset] + front := &front_buffer.cells[cell_offset] + if back.Ch < ' ' { + back.Ch = ' ' + } + w := runewidth.RuneWidth(back.Ch) + if w == 0 || w == 2 && runewidth.IsAmbiguousWidth(back.Ch) { + w = 1 + } + if *back == *front { + x += w + continue + } + *front = *back + send_attr(back.Fg, back.Bg) + + if w == 2 && x == front_buffer.width-1 { + // there's not enough space for 2-cells rune, + // let's just put a space in there + send_char(x, y, ' ') + } else { + send_char(x, y, back.Ch) + if w == 2 { + next := cell_offset + 1 + front_buffer.cells[next] = Cell{ + Ch: 0, + Fg: back.Fg, + Bg: back.Bg, + } + } + } + x += w + } + } + if !is_cursor_hidden(cursor_x, cursor_y) { + write_cursor(cursor_x, cursor_y) + } + return flush() +} + +// Sets the position of the cursor. See also HideCursor(). +func SetCursor(x, y int) { + if is_cursor_hidden(cursor_x, cursor_y) && !is_cursor_hidden(x, y) { + outbuf.WriteString(funcs[t_show_cursor]) + } + + if !is_cursor_hidden(cursor_x, cursor_y) && is_cursor_hidden(x, y) { + outbuf.WriteString(funcs[t_hide_cursor]) + } + + cursor_x, cursor_y = x, y + if !is_cursor_hidden(cursor_x, cursor_y) { + write_cursor(cursor_x, cursor_y) + } +} + +// The shortcut for SetCursor(-1, -1). +func HideCursor() { + SetCursor(cursor_hidden, cursor_hidden) +} + +// Changes cell's parameters in the internal back buffer at the specified +// position. +func SetCell(x, y int, ch rune, fg, bg Attribute) { + if x < 0 || x >= back_buffer.width { + return + } + if y < 0 || y >= back_buffer.height { + return + } + + back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg} +} + +// Returns a slice into the termbox's back buffer. You can get its dimensions +// using 'Size' function. The slice remains valid as long as no 'Clear' or +// 'Flush' function calls were made after call to this function. +func CellBuffer() []Cell { + return back_buffer.cells +} + +// After getting a raw event from PollRawEvent function call, you can parse it +// again into an ordinary one using termbox logic. That is parse an event as +// termbox would do it. Returned event in addition to usual Event struct fields +// sets N field to the amount of bytes used within 'data' slice. If the length +// of 'data' slice is zero or event cannot be parsed for some other reason, the +// function will return a special event type: EventNone. +// +// IMPORTANT: EventNone may contain a non-zero N, which means you should skip +// these bytes, because termbox cannot recognize them. +// +// NOTE: This API is experimental and may change in future. +func ParseEvent(data []byte) Event { + event := Event{Type: EventKey} + ok := extract_event(data, &event) + if !ok { + return Event{Type: EventNone, N: event.N} + } + return event +} + +// Wait for an event and return it. This is a blocking function call. Instead +// of EventKey and EventMouse it returns EventRaw events. Raw event is written +// into `data` slice and Event's N field is set to the amount of bytes written. +// The minimum required length of the 'data' slice is 1. This requirement may +// vary on different platforms. +// +// NOTE: This API is experimental and may change in future. +func PollRawEvent(data []byte) Event { + if len(data) == 0 { + panic("len(data) >= 1 is a requirement") + } + + var event Event + if extract_raw_event(data, &event) { + return event + } + + for { + select { + case ev := <-input_comm: + if ev.err != nil { + return Event{Type: EventError, Err: ev.err} + } + + inbuf = append(inbuf, ev.data...) + input_comm <- ev + if extract_raw_event(data, &event) { + return event + } + case <-interrupt_comm: + event.Type = EventInterrupt + return event + + case <-sigwinch: + event.Type = EventResize + event.Width, event.Height = get_term_size(out.Fd()) + return event + } + } +} + +// Wait for an event and return it. This is a blocking function call. +func PollEvent() Event { + var event Event + + // try to extract event from input buffer, return on success + event.Type = EventKey + ok := extract_event(inbuf, &event) + if event.N != 0 { + copy(inbuf, inbuf[event.N:]) + inbuf = inbuf[:len(inbuf)-event.N] + } + if ok { + return event + } + + for { + select { + case ev := <-input_comm: + if ev.err != nil { + return Event{Type: EventError, Err: ev.err} + } + + inbuf = append(inbuf, ev.data...) + input_comm <- ev + ok := extract_event(inbuf, &event) + if event.N != 0 { + copy(inbuf, inbuf[event.N:]) + inbuf = inbuf[:len(inbuf)-event.N] + } + if ok { + return event + } + case <-interrupt_comm: + event.Type = EventInterrupt + return event + + case <-sigwinch: + event.Type = EventResize + event.Width, event.Height = get_term_size(out.Fd()) + return event + } + } + panic("unreachable") +} + +// Returns the size of the internal back buffer (which is mostly the same as +// terminal's window size in characters). But it doesn't always match the size +// of the terminal window, after the terminal size has changed, the internal +// back buffer will get in sync only after Clear or Flush function calls. +func Size() (int, int) { + return termw, termh +} + +// Clears the internal back buffer. +func Clear(fg, bg Attribute) error { + foreground, background = fg, bg + err := update_size_maybe() + back_buffer.clear() + return err +} + +// Sets termbox input mode. Termbox has two input modes: +// +// 1. Esc input mode. When ESC sequence is in the buffer and it doesn't match +// any known sequence. ESC means KeyEsc. This is the default input mode. +// +// 2. Alt input mode. When ESC sequence is in the buffer and it doesn't match +// any known sequence. ESC enables ModAlt modifier for the next keyboard event. +// +// Both input modes can be OR'ed with Mouse mode. Setting Mouse mode bit up will +// enable mouse button click events. +// +// If 'mode' is InputCurrent, returns the current input mode. See also Input* +// constants. +func SetInputMode(mode InputMode) InputMode { + if mode == InputCurrent { + return input_mode + } + if mode&InputMouse != 0 { + out.WriteString(funcs[t_enter_mouse]) + } else { + out.WriteString(funcs[t_exit_mouse]) + } + + input_mode = mode + return input_mode +} + +// Sets the termbox output mode. Termbox has four output options: +// 1. OutputNormal => [1..8] +// This mode provides 8 different colors: +// black, red, green, yellow, blue, magenta, cyan, white +// Shortcut: ColorBlack, ColorRed, ... +// Attributes: AttrBold, AttrUnderline, AttrReverse +// +// Example usage: +// SetCell(x, y, '@', ColorBlack | AttrBold, ColorRed); +// +// 2. Output256 => [1..256] +// In this mode you can leverage the 256 terminal mode: +// 0x00 - 0x07: the 8 colors as in OutputNormal +// 0x08 - 0x0f: Color* | AttrBold +// 0x10 - 0xe7: 216 different colors +// 0xe8 - 0xff: 24 different shades of grey +// +// Example usage: +// SetCell(x, y, '@', 184, 240); +// SetCell(x, y, '@', 0xb8, 0xf0); +// +// 3. Output216 => [1..216] +// This mode supports the 3rd range of the 256 mode only. +// But you dont need to provide an offset. +// +// 4. OutputGrayscale => [1..24] +// This mode supports the 4th range of the 256 mode only. +// But you dont need to provide an offset. +// +// In all modes, 0 represents the default color. +// +// `go run _demos/output.go` to see its impact on your terminal. +// +// If 'mode' is OutputCurrent, it returns the current output mode. +// +// Note that this may return a different OutputMode than the one requested, +// as the requested mode may not be available on the target platform. +func SetOutputMode(mode OutputMode) OutputMode { + if mode == OutputCurrent { + return output_mode + } + + output_mode = mode + return output_mode +} + +// Sync comes handy when something causes desync between termbox's understanding +// of a terminal buffer and the reality. Such as a third party process. Sync +// forces a complete resync between the termbox and a terminal, it may not be +// visually pretty though. +func Sync() error { + front_buffer.clear() + err := send_clear() + if err != nil { + return err + } + + return Flush() +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/api_common.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/api_common.go new file mode 100644 index 000000000..c0069fb28 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/api_common.go @@ -0,0 +1,183 @@ +// termbox is a library for creating cross-platform text-based interfaces +package termbox + +// public API, common OS agnostic part + +type ( + InputMode int + OutputMode int + EventType uint8 + Modifier uint8 + Key uint16 + Attribute uint16 +) + +// This type represents a termbox event. The 'Mod', 'Key' and 'Ch' fields are +// valid if 'Type' is EventKey. The 'Width' and 'Height' fields are valid if +// 'Type' is EventResize. The 'Err' field is valid if 'Type' is EventError. +type Event struct { + Type EventType // one of Event* constants + Mod Modifier // one of Mod* constants or 0 + Key Key // one of Key* constants, invalid if 'Ch' is not 0 + Ch rune // a unicode character + Width int // width of the screen + Height int // height of the screen + Err error // error in case if input failed + MouseX int // x coord of mouse + MouseY int // y coord of mouse + N int // number of bytes written when getting a raw event +} + +// A cell, single conceptual entity on the screen. The screen is basically a 2d +// array of cells. 'Ch' is a unicode character, 'Fg' and 'Bg' are foreground +// and background attributes respectively. +type Cell struct { + Ch rune + Fg Attribute + Bg Attribute +} + +// To know if termbox has been initialized or not +var ( + IsInit bool = false +) + +// Key constants, see Event.Key field. +const ( + KeyF1 Key = 0xFFFF - iota + KeyF2 + KeyF3 + KeyF4 + KeyF5 + KeyF6 + KeyF7 + KeyF8 + KeyF9 + KeyF10 + KeyF11 + KeyF12 + KeyInsert + KeyDelete + KeyHome + KeyEnd + KeyPgup + KeyPgdn + KeyArrowUp + KeyArrowDown + KeyArrowLeft + KeyArrowRight + key_min // see terminfo + MouseLeft + MouseMiddle + MouseRight +) + +const ( + KeyCtrlTilde Key = 0x00 + KeyCtrl2 Key = 0x00 + KeyCtrlSpace Key = 0x00 + KeyCtrlA Key = 0x01 + KeyCtrlB Key = 0x02 + KeyCtrlC Key = 0x03 + KeyCtrlD Key = 0x04 + KeyCtrlE Key = 0x05 + KeyCtrlF Key = 0x06 + KeyCtrlG Key = 0x07 + KeyBackspace Key = 0x08 + KeyCtrlH Key = 0x08 + KeyTab Key = 0x09 + KeyCtrlI Key = 0x09 + KeyCtrlJ Key = 0x0A + KeyCtrlK Key = 0x0B + KeyCtrlL Key = 0x0C + KeyEnter Key = 0x0D + KeyCtrlM Key = 0x0D + KeyCtrlN Key = 0x0E + KeyCtrlO Key = 0x0F + KeyCtrlP Key = 0x10 + KeyCtrlQ Key = 0x11 + KeyCtrlR Key = 0x12 + KeyCtrlS Key = 0x13 + KeyCtrlT Key = 0x14 + KeyCtrlU Key = 0x15 + KeyCtrlV Key = 0x16 + KeyCtrlW Key = 0x17 + KeyCtrlX Key = 0x18 + KeyCtrlY Key = 0x19 + KeyCtrlZ Key = 0x1A + KeyEsc Key = 0x1B + KeyCtrlLsqBracket Key = 0x1B + KeyCtrl3 Key = 0x1B + KeyCtrl4 Key = 0x1C + KeyCtrlBackslash Key = 0x1C + KeyCtrl5 Key = 0x1D + KeyCtrlRsqBracket Key = 0x1D + KeyCtrl6 Key = 0x1E + KeyCtrl7 Key = 0x1F + KeyCtrlSlash Key = 0x1F + KeyCtrlUnderscore Key = 0x1F + KeySpace Key = 0x20 + KeyBackspace2 Key = 0x7F + KeyCtrl8 Key = 0x7F +) + +// Alt modifier constant, see Event.Mod field and SetInputMode function. +const ( + ModAlt Modifier = 0x01 +) + +// Cell colors, you can combine a color with multiple attributes using bitwise +// OR ('|'). +const ( + ColorDefault Attribute = iota + ColorBlack + ColorRed + ColorGreen + ColorYellow + ColorBlue + ColorMagenta + ColorCyan + ColorWhite +) + +// Cell attributes, it is possible to use multiple attributes by combining them +// using bitwise OR ('|'). Although, colors cannot be combined. But you can +// combine attributes and a single color. +// +// It's worth mentioning that some platforms don't support certain attibutes. +// For example windows console doesn't support AttrUnderline. And on some +// terminals applying AttrBold to background may result in blinking text. Use +// them with caution and test your code on various terminals. +const ( + AttrBold Attribute = 1 << (iota + 9) + AttrUnderline + AttrReverse +) + +// Input mode. See SetInputMode function. +const ( + InputEsc InputMode = 1 << iota + InputAlt + InputMouse + InputCurrent InputMode = 0 +) + +// Output mode. See SetOutputMode function. +const ( + OutputCurrent OutputMode = iota + OutputNormal + Output256 + Output216 + OutputGrayscale +) + +// Event type. See Event.Type field. +const ( + EventKey EventType = iota + EventResize + EventMouse + EventError + EventInterrupt + EventRaw + EventNone +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/api_windows.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/api_windows.go new file mode 100644 index 000000000..78d954b36 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/api_windows.go @@ -0,0 +1,235 @@ +package termbox + +import ( + "syscall" +) + +// public API + +// Initializes termbox library. This function should be called before any other functions. +// After successful initialization, the library must be finalized using 'Close' function. +// +// Example usage: +// err := termbox.Init() +// if err != nil { +// panic(err) +// } +// defer termbox.Close() +func Init() error { + var err error + + interrupt, err = create_event() + if err != nil { + return err + } + + in, err = syscall.Open("CONIN$", syscall.O_RDWR, 0) + if err != nil { + return err + } + out, err = syscall.Open("CONOUT$", syscall.O_RDWR, 0) + if err != nil { + return err + } + + err = get_console_mode(in, &orig_mode) + if err != nil { + return err + } + + err = set_console_mode(in, enable_window_input) + if err != nil { + return err + } + + orig_size = get_term_size(out) + win_size := get_win_size(out) + + err = set_console_screen_buffer_size(out, win_size) + if err != nil { + return err + } + + err = get_console_cursor_info(out, &orig_cursor_info) + if err != nil { + return err + } + + show_cursor(false) + term_size = get_term_size(out) + back_buffer.init(int(term_size.x), int(term_size.y)) + front_buffer.init(int(term_size.x), int(term_size.y)) + back_buffer.clear() + front_buffer.clear() + clear() + + diffbuf = make([]diff_msg, 0, 32) + + go input_event_producer() + IsInit = true + return nil +} + +// Finalizes termbox library, should be called after successful initialization +// when termbox's functionality isn't required anymore. +func Close() { + // we ignore errors here, because we can't really do anything about them + Clear(0, 0) + Flush() + + // stop event producer + cancel_comm <- true + set_event(interrupt) + <-cancel_done_comm + + set_console_cursor_info(out, &orig_cursor_info) + set_console_cursor_position(out, coord{}) + set_console_screen_buffer_size(out, orig_size) + set_console_mode(in, orig_mode) + syscall.Close(in) + syscall.Close(out) + syscall.Close(interrupt) + IsInit = false +} + +// Interrupt an in-progress call to PollEvent by causing it to return +// EventInterrupt. Note that this function will block until the PollEvent +// function has successfully been interrupted. +func Interrupt() { + interrupt_comm <- struct{}{} +} + +// Synchronizes the internal back buffer with the terminal. +func Flush() error { + update_size_maybe() + prepare_diff_messages() + for _, diff := range diffbuf { + r := small_rect{ + left: 0, + top: diff.pos, + right: term_size.x - 1, + bottom: diff.pos + diff.lines - 1, + } + write_console_output(out, diff.chars, r) + } + if !is_cursor_hidden(cursor_x, cursor_y) { + move_cursor(cursor_x, cursor_y) + } + return nil +} + +// Sets the position of the cursor. See also HideCursor(). +func SetCursor(x, y int) { + if is_cursor_hidden(cursor_x, cursor_y) && !is_cursor_hidden(x, y) { + show_cursor(true) + } + + if !is_cursor_hidden(cursor_x, cursor_y) && is_cursor_hidden(x, y) { + show_cursor(false) + } + + cursor_x, cursor_y = x, y + if !is_cursor_hidden(cursor_x, cursor_y) { + move_cursor(cursor_x, cursor_y) + } +} + +// The shortcut for SetCursor(-1, -1). +func HideCursor() { + SetCursor(cursor_hidden, cursor_hidden) +} + +// Changes cell's parameters in the internal back buffer at the specified +// position. +func SetCell(x, y int, ch rune, fg, bg Attribute) { + if x < 0 || x >= back_buffer.width { + return + } + if y < 0 || y >= back_buffer.height { + return + } + + back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg} +} + +// Returns a slice into the termbox's back buffer. You can get its dimensions +// using 'Size' function. The slice remains valid as long as no 'Clear' or +// 'Flush' function calls were made after call to this function. +func CellBuffer() []Cell { + return back_buffer.cells +} + +// Wait for an event and return it. This is a blocking function call. +func PollEvent() Event { + select { + case ev := <-input_comm: + return ev + case <-interrupt_comm: + return Event{Type: EventInterrupt} + } +} + +// Returns the size of the internal back buffer (which is mostly the same as +// console's window size in characters). But it doesn't always match the size +// of the console window, after the console size has changed, the internal back +// buffer will get in sync only after Clear or Flush function calls. +func Size() (int, int) { + return int(term_size.x), int(term_size.y) +} + +// Clears the internal back buffer. +func Clear(fg, bg Attribute) error { + foreground, background = fg, bg + update_size_maybe() + back_buffer.clear() + return nil +} + +// Sets termbox input mode. Termbox has two input modes: +// +// 1. Esc input mode. When ESC sequence is in the buffer and it doesn't match +// any known sequence. ESC means KeyEsc. This is the default input mode. +// +// 2. Alt input mode. When ESC sequence is in the buffer and it doesn't match +// any known sequence. ESC enables ModAlt modifier for the next keyboard event. +// +// Both input modes can be OR'ed with Mouse mode. Setting Mouse mode bit up will +// enable mouse button click events. +// +// If 'mode' is InputCurrent, returns the current input mode. See also Input* +// constants. +func SetInputMode(mode InputMode) InputMode { + if mode == InputCurrent { + return input_mode + } + if mode&InputMouse != 0 { + err := set_console_mode(in, enable_window_input|enable_mouse_input|enable_extended_flags) + if err != nil { + panic(err) + } + } else { + err := set_console_mode(in, enable_window_input) + if err != nil { + panic(err) + } + } + + input_mode = mode + return input_mode +} + +// Sets the termbox output mode. +// +// Windows console does not support extra colour modes, +// so this will always set and return OutputNormal. +func SetOutputMode(mode OutputMode) OutputMode { + return OutputNormal +} + +// Sync comes handy when something causes desync between termbox's understanding +// of a terminal buffer and the reality. Such as a third party process. Sync +// forces a complete resync between the termbox and a terminal, it may not be +// visually pretty though. At the moment on Windows it does nothing. +func Sync() error { + return nil +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/collect_terminfo.py b/Godeps/_workspace/src/github.com/nsf/termbox-go/collect_terminfo.py new file mode 100644 index 000000000..5e50975e6 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/collect_terminfo.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python + +import sys, os, subprocess + +def escaped(s): + return repr(s)[1:-1] + +def tput(term, name): + try: + return subprocess.check_output(['tput', '-T%s' % term, name]).decode() + except subprocess.CalledProcessError as e: + return e.output.decode() + + +def w(s): + if s == None: + return + sys.stdout.write(s) + +terminals = { + 'xterm' : 'xterm', + 'rxvt-256color' : 'rxvt_256color', + 'rxvt-unicode' : 'rxvt_unicode', + 'linux' : 'linux', + 'Eterm' : 'eterm', + 'screen' : 'screen' +} + +keys = [ + "F1", "kf1", + "F2", "kf2", + "F3", "kf3", + "F4", "kf4", + "F5", "kf5", + "F6", "kf6", + "F7", "kf7", + "F8", "kf8", + "F9", "kf9", + "F10", "kf10", + "F11", "kf11", + "F12", "kf12", + "INSERT", "kich1", + "DELETE", "kdch1", + "HOME", "khome", + "END", "kend", + "PGUP", "kpp", + "PGDN", "knp", + "KEY_UP", "kcuu1", + "KEY_DOWN", "kcud1", + "KEY_LEFT", "kcub1", + "KEY_RIGHT", "kcuf1" +] + +funcs = [ + "T_ENTER_CA", "smcup", + "T_EXIT_CA", "rmcup", + "T_SHOW_CURSOR", "cnorm", + "T_HIDE_CURSOR", "civis", + "T_CLEAR_SCREEN", "clear", + "T_SGR0", "sgr0", + "T_UNDERLINE", "smul", + "T_BOLD", "bold", + "T_BLINK", "blink", + "T_REVERSE", "rev", + "T_ENTER_KEYPAD", "smkx", + "T_EXIT_KEYPAD", "rmkx" +] + +def iter_pairs(iterable): + iterable = iter(iterable) + while True: + yield (next(iterable), next(iterable)) + +def do_term(term, nick): + w("// %s\n" % term) + w("var %s_keys = []string{\n\t" % nick) + for k, v in iter_pairs(keys): + w('"') + w(escaped(tput(term, v))) + w('",') + w("\n}\n") + w("var %s_funcs = []string{\n\t" % nick) + for k,v in iter_pairs(funcs): + w('"') + if v == "sgr": + w("\\033[3%d;4%dm") + elif v == "cup": + w("\\033[%d;%dH") + else: + w(escaped(tput(term, v))) + w('", ') + w("\n}\n\n") + +def do_terms(d): + w("var terms = []struct {\n") + w("\tname string\n") + w("\tkeys []string\n") + w("\tfuncs []string\n") + w("}{\n") + for k, v in d.items(): + w('\t{"%s", %s_keys, %s_funcs},\n' % (k, v, v)) + w("}\n\n") + +w("// +build !windows\n\npackage termbox\n\n") + +for k,v in terminals.items(): + do_term(k, v) + +do_terms(terminals) + diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls.go new file mode 100644 index 000000000..4f52bb9af --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls.go @@ -0,0 +1,39 @@ +// +build ignore + +package termbox + +/* +#include +#include +*/ +import "C" + +type syscall_Termios C.struct_termios + +const ( + syscall_IGNBRK = C.IGNBRK + syscall_BRKINT = C.BRKINT + syscall_PARMRK = C.PARMRK + syscall_ISTRIP = C.ISTRIP + syscall_INLCR = C.INLCR + syscall_IGNCR = C.IGNCR + syscall_ICRNL = C.ICRNL + syscall_IXON = C.IXON + syscall_OPOST = C.OPOST + syscall_ECHO = C.ECHO + syscall_ECHONL = C.ECHONL + syscall_ICANON = C.ICANON + syscall_ISIG = C.ISIG + syscall_IEXTEN = C.IEXTEN + syscall_CSIZE = C.CSIZE + syscall_PARENB = C.PARENB + syscall_CS8 = C.CS8 + syscall_VMIN = C.VMIN + syscall_VTIME = C.VTIME + + // on darwin change these to (on *bsd too?): + // C.TIOCGETA + // C.TIOCSETA + syscall_TCGETS = C.TCGETS + syscall_TCSETS = C.TCSETS +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_darwin_386.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_darwin_386.go new file mode 100644 index 000000000..e03624ebc --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_darwin_386.go @@ -0,0 +1,39 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs syscalls.go + +package termbox + +type syscall_Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} + +const ( + syscall_IGNBRK = 0x1 + syscall_BRKINT = 0x2 + syscall_PARMRK = 0x8 + syscall_ISTRIP = 0x20 + syscall_INLCR = 0x40 + syscall_IGNCR = 0x80 + syscall_ICRNL = 0x100 + syscall_IXON = 0x200 + syscall_OPOST = 0x1 + syscall_ECHO = 0x8 + syscall_ECHONL = 0x10 + syscall_ICANON = 0x100 + syscall_ISIG = 0x80 + syscall_IEXTEN = 0x400 + syscall_CSIZE = 0x300 + syscall_PARENB = 0x1000 + syscall_CS8 = 0x300 + syscall_VMIN = 0x10 + syscall_VTIME = 0x11 + + syscall_TCGETS = 0x402c7413 + syscall_TCSETS = 0x802c7414 +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_darwin_amd64.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_darwin_amd64.go new file mode 100644 index 000000000..11f25be79 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_darwin_amd64.go @@ -0,0 +1,40 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs syscalls.go + +package termbox + +type syscall_Termios struct { + Iflag uint64 + Oflag uint64 + Cflag uint64 + Lflag uint64 + Cc [20]uint8 + Pad_cgo_0 [4]byte + Ispeed uint64 + Ospeed uint64 +} + +const ( + syscall_IGNBRK = 0x1 + syscall_BRKINT = 0x2 + syscall_PARMRK = 0x8 + syscall_ISTRIP = 0x20 + syscall_INLCR = 0x40 + syscall_IGNCR = 0x80 + syscall_ICRNL = 0x100 + syscall_IXON = 0x200 + syscall_OPOST = 0x1 + syscall_ECHO = 0x8 + syscall_ECHONL = 0x10 + syscall_ICANON = 0x100 + syscall_ISIG = 0x80 + syscall_IEXTEN = 0x400 + syscall_CSIZE = 0x300 + syscall_PARENB = 0x1000 + syscall_CS8 = 0x300 + syscall_VMIN = 0x10 + syscall_VTIME = 0x11 + + syscall_TCGETS = 0x40487413 + syscall_TCSETS = 0x80487414 +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_freebsd.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_freebsd.go new file mode 100644 index 000000000..e03624ebc --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_freebsd.go @@ -0,0 +1,39 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs syscalls.go + +package termbox + +type syscall_Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} + +const ( + syscall_IGNBRK = 0x1 + syscall_BRKINT = 0x2 + syscall_PARMRK = 0x8 + syscall_ISTRIP = 0x20 + syscall_INLCR = 0x40 + syscall_IGNCR = 0x80 + syscall_ICRNL = 0x100 + syscall_IXON = 0x200 + syscall_OPOST = 0x1 + syscall_ECHO = 0x8 + syscall_ECHONL = 0x10 + syscall_ICANON = 0x100 + syscall_ISIG = 0x80 + syscall_IEXTEN = 0x400 + syscall_CSIZE = 0x300 + syscall_PARENB = 0x1000 + syscall_CS8 = 0x300 + syscall_VMIN = 0x10 + syscall_VTIME = 0x11 + + syscall_TCGETS = 0x402c7413 + syscall_TCSETS = 0x802c7414 +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_linux.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_linux.go new file mode 100644 index 000000000..b88960de6 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_linux.go @@ -0,0 +1,33 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs syscalls.go + +package termbox + +import "syscall" + +type syscall_Termios syscall.Termios + +const ( + syscall_IGNBRK = syscall.IGNBRK + syscall_BRKINT = syscall.BRKINT + syscall_PARMRK = syscall.PARMRK + syscall_ISTRIP = syscall.ISTRIP + syscall_INLCR = syscall.INLCR + syscall_IGNCR = syscall.IGNCR + syscall_ICRNL = syscall.ICRNL + syscall_IXON = syscall.IXON + syscall_OPOST = syscall.OPOST + syscall_ECHO = syscall.ECHO + syscall_ECHONL = syscall.ECHONL + syscall_ICANON = syscall.ICANON + syscall_ISIG = syscall.ISIG + syscall_IEXTEN = syscall.IEXTEN + syscall_CSIZE = syscall.CSIZE + syscall_PARENB = syscall.PARENB + syscall_CS8 = syscall.CS8 + syscall_VMIN = syscall.VMIN + syscall_VTIME = syscall.VTIME + + syscall_TCGETS = syscall.TCGETS + syscall_TCSETS = syscall.TCSETS +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_netbsd.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_netbsd.go new file mode 100644 index 000000000..49a3355b9 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_netbsd.go @@ -0,0 +1,39 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs syscalls.go + +package termbox + +type syscall_Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} + +const ( + syscall_IGNBRK = 0x1 + syscall_BRKINT = 0x2 + syscall_PARMRK = 0x8 + syscall_ISTRIP = 0x20 + syscall_INLCR = 0x40 + syscall_IGNCR = 0x80 + syscall_ICRNL = 0x100 + syscall_IXON = 0x200 + syscall_OPOST = 0x1 + syscall_ECHO = 0x8 + syscall_ECHONL = 0x10 + syscall_ICANON = 0x100 + syscall_ISIG = 0x80 + syscall_IEXTEN = 0x400 + syscall_CSIZE = 0x300 + syscall_PARENB = 0x1000 + syscall_CS8 = 0x300 + syscall_VMIN = 0x10 + syscall_VTIME = 0x11 + + syscall_TCGETS = 0x402c7413 + syscall_TCSETS = 0x802c7414 +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_openbsd.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_openbsd.go new file mode 100644 index 000000000..49a3355b9 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_openbsd.go @@ -0,0 +1,39 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs syscalls.go + +package termbox + +type syscall_Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} + +const ( + syscall_IGNBRK = 0x1 + syscall_BRKINT = 0x2 + syscall_PARMRK = 0x8 + syscall_ISTRIP = 0x20 + syscall_INLCR = 0x40 + syscall_IGNCR = 0x80 + syscall_ICRNL = 0x100 + syscall_IXON = 0x200 + syscall_OPOST = 0x1 + syscall_ECHO = 0x8 + syscall_ECHONL = 0x10 + syscall_ICANON = 0x100 + syscall_ISIG = 0x80 + syscall_IEXTEN = 0x400 + syscall_CSIZE = 0x300 + syscall_PARENB = 0x1000 + syscall_CS8 = 0x300 + syscall_VMIN = 0x10 + syscall_VTIME = 0x11 + + syscall_TCGETS = 0x402c7413 + syscall_TCSETS = 0x802c7414 +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_windows.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_windows.go new file mode 100644 index 000000000..472d002a5 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/syscalls_windows.go @@ -0,0 +1,61 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs -- -DUNICODE syscalls.go + +package termbox + +const ( + foreground_blue = 0x1 + foreground_green = 0x2 + foreground_red = 0x4 + foreground_intensity = 0x8 + background_blue = 0x10 + background_green = 0x20 + background_red = 0x40 + background_intensity = 0x80 + std_input_handle = -0xa + std_output_handle = -0xb + key_event = 0x1 + mouse_event = 0x2 + window_buffer_size_event = 0x4 + enable_window_input = 0x8 + enable_mouse_input = 0x10 + enable_extended_flags = 0x80 + + vk_f1 = 0x70 + vk_f2 = 0x71 + vk_f3 = 0x72 + vk_f4 = 0x73 + vk_f5 = 0x74 + vk_f6 = 0x75 + vk_f7 = 0x76 + vk_f8 = 0x77 + vk_f9 = 0x78 + vk_f10 = 0x79 + vk_f11 = 0x7a + vk_f12 = 0x7b + vk_insert = 0x2d + vk_delete = 0x2e + vk_home = 0x24 + vk_end = 0x23 + vk_pgup = 0x21 + vk_pgdn = 0x22 + vk_arrow_up = 0x26 + vk_arrow_down = 0x28 + vk_arrow_left = 0x25 + vk_arrow_right = 0x27 + vk_backspace = 0x8 + vk_tab = 0x9 + vk_enter = 0xd + vk_esc = 0x1b + vk_space = 0x20 + + left_alt_pressed = 0x2 + left_ctrl_pressed = 0x8 + right_alt_pressed = 0x1 + right_ctrl_pressed = 0x4 + shift_pressed = 0x10 + + generic_read = 0x80000000 + generic_write = 0x40000000 + console_textmode_buffer = 0x1 +) diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox.go new file mode 100644 index 000000000..0aee8aca9 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox.go @@ -0,0 +1,407 @@ +// +build !windows + +package termbox + +import "unicode/utf8" +import "bytes" +import "syscall" +import "unsafe" +import "strings" +import "strconv" +import "os" +import "io" + +// private API + +const ( + t_enter_ca = iota + t_exit_ca + t_show_cursor + t_hide_cursor + t_clear_screen + t_sgr0 + t_underline + t_bold + t_blink + t_reverse + t_enter_keypad + t_exit_keypad + t_enter_mouse + t_exit_mouse + t_max_funcs +) + +const ( + coord_invalid = -2 + attr_invalid = Attribute(0xFFFF) +) + +type input_event struct { + data []byte + err error +} + +var ( + // term specific sequences + keys []string + funcs []string + + // termbox inner state + orig_tios syscall_Termios + back_buffer cellbuf + front_buffer cellbuf + termw int + termh int + input_mode = InputEsc + output_mode = OutputNormal + out *os.File + in int + lastfg = attr_invalid + lastbg = attr_invalid + lastx = coord_invalid + lasty = coord_invalid + cursor_x = cursor_hidden + cursor_y = cursor_hidden + foreground = ColorDefault + background = ColorDefault + inbuf = make([]byte, 0, 64) + outbuf bytes.Buffer + sigwinch = make(chan os.Signal, 1) + sigio = make(chan os.Signal, 1) + quit = make(chan int) + input_comm = make(chan input_event) + interrupt_comm = make(chan struct{}) + intbuf = make([]byte, 0, 16) +) + +func write_cursor(x, y int) { + outbuf.WriteString("\033[") + outbuf.Write(strconv.AppendUint(intbuf, uint64(y+1), 10)) + outbuf.WriteString(";") + outbuf.Write(strconv.AppendUint(intbuf, uint64(x+1), 10)) + outbuf.WriteString("H") +} + +func write_sgr_fg(a Attribute) { + switch output_mode { + case Output256, Output216, OutputGrayscale: + outbuf.WriteString("\033[38;5;") + outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) + outbuf.WriteString("m") + default: + outbuf.WriteString("\033[3") + outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) + outbuf.WriteString("m") + } +} + +func write_sgr_bg(a Attribute) { + switch output_mode { + case Output256, Output216, OutputGrayscale: + outbuf.WriteString("\033[48;5;") + outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) + outbuf.WriteString("m") + default: + outbuf.WriteString("\033[4") + outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) + outbuf.WriteString("m") + } +} + +func write_sgr(fg, bg Attribute) { + switch output_mode { + case Output256, Output216, OutputGrayscale: + outbuf.WriteString("\033[38;5;") + outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) + outbuf.WriteString("m") + outbuf.WriteString("\033[48;5;") + outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) + outbuf.WriteString("m") + default: + outbuf.WriteString("\033[3") + outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) + outbuf.WriteString(";4") + outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) + outbuf.WriteString("m") + } +} + +type winsize struct { + rows uint16 + cols uint16 + xpixels uint16 + ypixels uint16 +} + +func get_term_size(fd uintptr) (int, int) { + var sz winsize + _, _, _ = syscall.Syscall(syscall.SYS_IOCTL, + fd, uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&sz))) + return int(sz.cols), int(sz.rows) +} + +func send_attr(fg, bg Attribute) { + if fg == lastfg && bg == lastbg { + return + } + + outbuf.WriteString(funcs[t_sgr0]) + + var fgcol, bgcol Attribute + + switch output_mode { + case Output256: + fgcol = fg & 0x1FF + bgcol = bg & 0x1FF + case Output216: + fgcol = fg & 0xFF + bgcol = bg & 0xFF + if fgcol > 216 { + fgcol = ColorDefault + } + if bgcol > 216 { + bgcol = ColorDefault + } + if fgcol != ColorDefault { + fgcol += 0x10 + } + if bgcol != ColorDefault { + bgcol += 0x10 + } + case OutputGrayscale: + fgcol = fg & 0x1F + bgcol = bg & 0x1F + if fgcol > 24 { + fgcol = ColorDefault + } + if bgcol > 24 { + bgcol = ColorDefault + } + if fgcol != ColorDefault { + fgcol += 0xe8 + } + if bgcol != ColorDefault { + bgcol += 0xe8 + } + default: + fgcol = fg & 0x0F + bgcol = bg & 0x0F + } + + if fgcol != ColorDefault { + if bgcol != ColorDefault { + write_sgr(fgcol, bgcol) + } else { + write_sgr_fg(fgcol) + } + } else if bgcol != ColorDefault { + write_sgr_bg(bgcol) + } + + if fg&AttrBold != 0 { + outbuf.WriteString(funcs[t_bold]) + } + if bg&AttrBold != 0 { + outbuf.WriteString(funcs[t_blink]) + } + if fg&AttrUnderline != 0 { + outbuf.WriteString(funcs[t_underline]) + } + if fg&AttrReverse|bg&AttrReverse != 0 { + outbuf.WriteString(funcs[t_reverse]) + } + + lastfg, lastbg = fg, bg +} + +func send_char(x, y int, ch rune) { + var buf [8]byte + n := utf8.EncodeRune(buf[:], ch) + if x-1 != lastx || y != lasty { + write_cursor(x, y) + } + lastx, lasty = x, y + outbuf.Write(buf[:n]) +} + +func flush() error { + _, err := io.Copy(out, &outbuf) + outbuf.Reset() + if err != nil { + return err + } + return nil +} + +func send_clear() error { + send_attr(foreground, background) + outbuf.WriteString(funcs[t_clear_screen]) + if !is_cursor_hidden(cursor_x, cursor_y) { + write_cursor(cursor_x, cursor_y) + } + + // we need to invalidate cursor position too and these two vars are + // used only for simple cursor positioning optimization, cursor + // actually may be in the correct place, but we simply discard + // optimization once and it gives us simple solution for the case when + // cursor moved + lastx = coord_invalid + lasty = coord_invalid + + return flush() +} + +func update_size_maybe() error { + w, h := get_term_size(out.Fd()) + if w != termw || h != termh { + termw, termh = w, h + back_buffer.resize(termw, termh) + front_buffer.resize(termw, termh) + front_buffer.clear() + return send_clear() + } + return nil +} + +func tcsetattr(fd uintptr, termios *syscall_Termios) error { + r, _, e := syscall.Syscall(syscall.SYS_IOCTL, + fd, uintptr(syscall_TCSETS), uintptr(unsafe.Pointer(termios))) + if r != 0 { + return os.NewSyscallError("SYS_IOCTL", e) + } + return nil +} + +func tcgetattr(fd uintptr, termios *syscall_Termios) error { + r, _, e := syscall.Syscall(syscall.SYS_IOCTL, + fd, uintptr(syscall_TCGETS), uintptr(unsafe.Pointer(termios))) + if r != 0 { + return os.NewSyscallError("SYS_IOCTL", e) + } + return nil +} + +func parse_escape_sequence(event *Event, buf []byte) (int, bool) { + bufstr := string(buf) + // mouse + if len(bufstr) >= 6 && strings.HasPrefix(bufstr, "\033[M") { + switch buf[3] & 3 { + case 0: + event.Key = MouseLeft + case 1: + event.Key = MouseMiddle + case 2: + event.Key = MouseRight + case 3: + return 6, false + } + event.Type = EventMouse // KeyEvent by default + // wheel up outputs MouseLeft + if buf[3] == 0x60 || buf[3] == 0x70 { + event.Key = MouseMiddle + } + // the coord is 1,1 for upper left + event.MouseX = int(buf[4]) - 1 - 32 + event.MouseY = int(buf[5]) - 1 - 32 + return 6, true + } + + for i, key := range keys { + if strings.HasPrefix(bufstr, key) { + event.Ch = 0 + event.Key = Key(0xFFFF - i) + return len(key), true + } + } + return 0, true +} + +func extract_raw_event(data []byte, event *Event) bool { + if len(inbuf) == 0 { + return false + } + + n := len(data) + if n == 0 { + return false + } + + n = copy(data, inbuf) + copy(inbuf, inbuf[n:]) + inbuf = inbuf[:len(inbuf)-n] + + event.N = n + event.Type = EventRaw + return true +} + +func extract_event(inbuf []byte, event *Event) bool { + if len(inbuf) == 0 { + event.N = 0 + return false + } + + if inbuf[0] == '\033' { + // possible escape sequence + n, ok := parse_escape_sequence(event, inbuf) + if n != 0 { + event.N = n + return ok + } + + // it's not escape sequence, then it's Alt or Esc, check input_mode + switch { + case input_mode&InputEsc != 0: + // if we're in escape mode, fill Esc event, pop buffer, return success + event.Ch = 0 + event.Key = KeyEsc + event.Mod = 0 + event.N = 1 + return true + case input_mode&InputAlt != 0: + // if we're in alt mode, set Alt modifier to event and redo parsing + event.Mod = ModAlt + ok := extract_event(inbuf[1:], event) + if ok { + event.N++ + } else { + event.N = 0 + } + return ok + default: + panic("unreachable") + } + } + + // if we're here, this is not an escape sequence and not an alt sequence + // so, it's a FUNCTIONAL KEY or a UNICODE character + + // first of all check if it's a functional key + if Key(inbuf[0]) <= KeySpace || Key(inbuf[0]) == KeyBackspace2 { + // fill event, pop buffer, return success + event.Ch = 0 + event.Key = Key(inbuf[0]) + event.N = 1 + return true + } + + // the only possible option is utf8 rune + if r, n := utf8.DecodeRune(inbuf); r != utf8.RuneError { + event.Ch = r + event.Key = 0 + event.N = n + return true + } + + return false +} + +func fcntl(fd int, cmd int, arg int) (val int, err error) { + r, _, e := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd), + uintptr(arg)) + val = int(r) + if e != 0 { + err = e + } + return +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox_common.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox_common.go new file mode 100644 index 000000000..c3355cc25 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox_common.go @@ -0,0 +1,59 @@ +package termbox + +// private API, common OS agnostic part + +type cellbuf struct { + width int + height int + cells []Cell +} + +func (this *cellbuf) init(width, height int) { + this.width = width + this.height = height + this.cells = make([]Cell, width*height) +} + +func (this *cellbuf) resize(width, height int) { + if this.width == width && this.height == height { + return + } + + oldw := this.width + oldh := this.height + oldcells := this.cells + + this.init(width, height) + this.clear() + + minw, minh := oldw, oldh + + if width < minw { + minw = width + } + if height < minh { + minh = height + } + + for i := 0; i < minh; i++ { + srco, dsto := i*oldw, i*width + src := oldcells[srco : srco+minw] + dst := this.cells[dsto : dsto+minw] + copy(dst, src) + } +} + +func (this *cellbuf) clear() { + for i := range this.cells { + c := &this.cells[i] + c.Ch = ' ' + c.Fg = foreground + c.Bg = background + } +} + +const cursor_hidden = -1 + +func is_cursor_hidden(x, y int) bool { + return x == cursor_hidden || y == cursor_hidden +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox_windows.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox_windows.go new file mode 100644 index 000000000..17d1bdc84 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/termbox_windows.go @@ -0,0 +1,813 @@ +package termbox + +import "syscall" +import "unsafe" +import "unicode/utf16" +import "github.com/mattn/go-runewidth" + +type ( + wchar uint16 + short int16 + dword uint32 + word uint16 + char_info struct { + char wchar + attr word + } + coord struct { + x short + y short + } + small_rect struct { + left short + top short + right short + bottom short + } + console_screen_buffer_info struct { + size coord + cursor_position coord + attributes word + window small_rect + maximum_window_size coord + } + console_cursor_info struct { + size dword + visible int32 + } + input_record struct { + event_type word + _ [2]byte + event [16]byte + } + key_event_record struct { + key_down int32 + repeat_count word + virtual_key_code word + virtual_scan_code word + unicode_char wchar + control_key_state dword + } + window_buffer_size_record struct { + size coord + } + mouse_event_record struct { + mouse_pos coord + button_state dword + control_key_state dword + event_flags dword + } +) + +const ( + mouse_lmb = 0x1 + mouse_rmb = 0x2 + mouse_mmb = 0x4 | 0x8 | 0x10 +) + +func (this coord) uintptr() uintptr { + return uintptr(*(*int32)(unsafe.Pointer(&this))) +} + +var kernel32 = syscall.NewLazyDLL("kernel32.dll") +var is_cjk = runewidth.IsEastAsian() + +var ( + proc_set_console_active_screen_buffer = kernel32.NewProc("SetConsoleActiveScreenBuffer") + proc_set_console_screen_buffer_size = kernel32.NewProc("SetConsoleScreenBufferSize") + proc_create_console_screen_buffer = kernel32.NewProc("CreateConsoleScreenBuffer") + proc_get_console_screen_buffer_info = kernel32.NewProc("GetConsoleScreenBufferInfo") + proc_write_console_output = kernel32.NewProc("WriteConsoleOutputW") + proc_write_console_output_character = kernel32.NewProc("WriteConsoleOutputCharacterW") + proc_write_console_output_attribute = kernel32.NewProc("WriteConsoleOutputAttribute") + proc_set_console_cursor_info = kernel32.NewProc("SetConsoleCursorInfo") + proc_set_console_cursor_position = kernel32.NewProc("SetConsoleCursorPosition") + proc_get_console_cursor_info = kernel32.NewProc("GetConsoleCursorInfo") + proc_read_console_input = kernel32.NewProc("ReadConsoleInputW") + proc_get_console_mode = kernel32.NewProc("GetConsoleMode") + proc_set_console_mode = kernel32.NewProc("SetConsoleMode") + proc_fill_console_output_character = kernel32.NewProc("FillConsoleOutputCharacterW") + proc_fill_console_output_attribute = kernel32.NewProc("FillConsoleOutputAttribute") + proc_create_event = kernel32.NewProc("CreateEventW") + proc_wait_for_multiple_objects = kernel32.NewProc("WaitForMultipleObjects") + proc_set_event = kernel32.NewProc("SetEvent") +) + +func set_console_active_screen_buffer(h syscall.Handle) (err error) { + r0, _, e1 := syscall.Syscall(proc_set_console_active_screen_buffer.Addr(), + 1, uintptr(h), 0, 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func set_console_screen_buffer_size(h syscall.Handle, size coord) (err error) { + r0, _, e1 := syscall.Syscall(proc_set_console_screen_buffer_size.Addr(), + 2, uintptr(h), size.uintptr(), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func create_console_screen_buffer() (h syscall.Handle, err error) { + r0, _, e1 := syscall.Syscall6(proc_create_console_screen_buffer.Addr(), + 5, uintptr(generic_read|generic_write), 0, 0, console_textmode_buffer, 0, 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return syscall.Handle(r0), nil +} + +func get_console_screen_buffer_info(h syscall.Handle, info *console_screen_buffer_info) (err error) { + r0, _, e1 := syscall.Syscall(proc_get_console_screen_buffer_info.Addr(), + 2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func write_console_output(h syscall.Handle, chars []char_info, dst small_rect) (err error) { + tmp_coord = coord{dst.right - dst.left + 1, dst.bottom - dst.top + 1} + tmp_rect = dst + r0, _, e1 := syscall.Syscall6(proc_write_console_output.Addr(), + 5, uintptr(h), uintptr(unsafe.Pointer(&chars[0])), tmp_coord.uintptr(), + tmp_coord0.uintptr(), uintptr(unsafe.Pointer(&tmp_rect)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func write_console_output_character(h syscall.Handle, chars []wchar, pos coord) (err error) { + r0, _, e1 := syscall.Syscall6(proc_write_console_output_character.Addr(), + 5, uintptr(h), uintptr(unsafe.Pointer(&chars[0])), uintptr(len(chars)), + pos.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func write_console_output_attribute(h syscall.Handle, attrs []word, pos coord) (err error) { + r0, _, e1 := syscall.Syscall6(proc_write_console_output_attribute.Addr(), + 5, uintptr(h), uintptr(unsafe.Pointer(&attrs[0])), uintptr(len(attrs)), + pos.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func set_console_cursor_info(h syscall.Handle, info *console_cursor_info) (err error) { + r0, _, e1 := syscall.Syscall(proc_set_console_cursor_info.Addr(), + 2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func get_console_cursor_info(h syscall.Handle, info *console_cursor_info) (err error) { + r0, _, e1 := syscall.Syscall(proc_get_console_cursor_info.Addr(), + 2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func set_console_cursor_position(h syscall.Handle, pos coord) (err error) { + r0, _, e1 := syscall.Syscall(proc_set_console_cursor_position.Addr(), + 2, uintptr(h), pos.uintptr(), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func read_console_input(h syscall.Handle, record *input_record) (err error) { + r0, _, e1 := syscall.Syscall6(proc_read_console_input.Addr(), + 4, uintptr(h), uintptr(unsafe.Pointer(record)), 1, uintptr(unsafe.Pointer(&tmp_arg)), 0, 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func get_console_mode(h syscall.Handle, mode *dword) (err error) { + r0, _, e1 := syscall.Syscall(proc_get_console_mode.Addr(), + 2, uintptr(h), uintptr(unsafe.Pointer(mode)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func set_console_mode(h syscall.Handle, mode dword) (err error) { + r0, _, e1 := syscall.Syscall(proc_set_console_mode.Addr(), + 2, uintptr(h), uintptr(mode), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func fill_console_output_character(h syscall.Handle, char wchar, n int) (err error) { + r0, _, e1 := syscall.Syscall6(proc_fill_console_output_character.Addr(), + 5, uintptr(h), uintptr(char), uintptr(n), tmp_coord.uintptr(), + uintptr(unsafe.Pointer(&tmp_arg)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func fill_console_output_attribute(h syscall.Handle, attr word, n int) (err error) { + r0, _, e1 := syscall.Syscall6(proc_fill_console_output_attribute.Addr(), + 5, uintptr(h), uintptr(attr), uintptr(n), tmp_coord.uintptr(), + uintptr(unsafe.Pointer(&tmp_arg)), 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func create_event() (out syscall.Handle, err error) { + r0, _, e1 := syscall.Syscall6(proc_create_event.Addr(), + 4, 0, 0, 0, 0, 0, 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return syscall.Handle(r0), nil +} + +func wait_for_multiple_objects(objects []syscall.Handle) (err error) { + r0, _, e1 := syscall.Syscall6(proc_wait_for_multiple_objects.Addr(), + 4, uintptr(len(objects)), uintptr(unsafe.Pointer(&objects[0])), + 0, 0xFFFFFFFF, 0, 0) + if uint32(r0) == 0xFFFFFFFF { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +func set_event(ev syscall.Handle) (err error) { + r0, _, e1 := syscall.Syscall(proc_set_event.Addr(), + 1, uintptr(ev), 0, 0) + if int(r0) == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} + +type diff_msg struct { + pos short + lines short + chars []char_info +} + +type input_event struct { + event Event + err error +} + +var ( + orig_cursor_info console_cursor_info + orig_size coord + orig_mode dword + orig_screen syscall.Handle + back_buffer cellbuf + front_buffer cellbuf + term_size coord + input_mode = InputEsc + cursor_x = cursor_hidden + cursor_y = cursor_hidden + foreground = ColorDefault + background = ColorDefault + in syscall.Handle + out syscall.Handle + interrupt syscall.Handle + charbuf []char_info + diffbuf []diff_msg + beg_x = -1 + beg_y = -1 + beg_i = -1 + input_comm = make(chan Event) + interrupt_comm = make(chan struct{}) + cancel_comm = make(chan bool, 1) + cancel_done_comm = make(chan bool) + alt_mode_esc = false + + // these ones just to prevent heap allocs at all costs + tmp_info console_screen_buffer_info + tmp_arg dword + tmp_coord0 = coord{0, 0} + tmp_coord = coord{0, 0} + tmp_rect = small_rect{0, 0, 0, 0} +) + +func get_cursor_position(out syscall.Handle) coord { + err := get_console_screen_buffer_info(out, &tmp_info) + if err != nil { + panic(err) + } + return tmp_info.cursor_position +} + +func get_term_size(out syscall.Handle) coord { + err := get_console_screen_buffer_info(out, &tmp_info) + if err != nil { + panic(err) + } + return tmp_info.size +} + +func get_win_size(out syscall.Handle) coord { + err := get_console_screen_buffer_info(out, &tmp_info) + if err != nil { + panic(err) + } + return coord{ + x: tmp_info.window.right - tmp_info.window.left + 1, + y: tmp_info.window.bottom - tmp_info.window.top + 1, + } +} + +func update_size_maybe() { + size := get_term_size(out) + if size.x != term_size.x || size.y != term_size.y { + term_size = size + back_buffer.resize(int(size.x), int(size.y)) + front_buffer.resize(int(size.x), int(size.y)) + front_buffer.clear() + clear() + + area := int(size.x) * int(size.y) + if cap(charbuf) < area { + charbuf = make([]char_info, 0, area) + } + } +} + +var color_table_bg = []word{ + 0, // default (black) + 0, // black + background_red, + background_green, + background_red | background_green, // yellow + background_blue, + background_red | background_blue, // magenta + background_green | background_blue, // cyan + background_red | background_blue | background_green, // white +} + +var color_table_fg = []word{ + foreground_red | foreground_blue | foreground_green, // default (white) + 0, + foreground_red, + foreground_green, + foreground_red | foreground_green, // yellow + foreground_blue, + foreground_red | foreground_blue, // magenta + foreground_green | foreground_blue, // cyan + foreground_red | foreground_blue | foreground_green, // white +} + +const ( + replacement_char = '\uFFFD' + max_rune = '\U0010FFFF' + surr1 = 0xd800 + surr2 = 0xdc00 + surr3 = 0xe000 + surr_self = 0x10000 +) + +func append_diff_line(y int) int { + n := 0 + for x := 0; x < front_buffer.width; { + cell_offset := y*front_buffer.width + x + back := &back_buffer.cells[cell_offset] + front := &front_buffer.cells[cell_offset] + attr, char := cell_to_char_info(*back) + charbuf = append(charbuf, char_info{attr: attr, char: char[0]}) + *front = *back + n++ + w := runewidth.RuneWidth(back.Ch) + if w == 0 || w == 2 && runewidth.IsAmbiguousWidth(back.Ch) { + w = 1 + } + x += w + // If not CJK, fill trailing space with whitespace + if !is_cjk && w == 2 { + charbuf = append(charbuf, char_info{attr: attr, char: ' '}) + } + } + return n +} + +// compares 'back_buffer' with 'front_buffer' and prepares all changes in the form of +// 'diff_msg's in the 'diff_buf' +func prepare_diff_messages() { + // clear buffers + diffbuf = diffbuf[:0] + charbuf = charbuf[:0] + + var diff diff_msg + gbeg := 0 + for y := 0; y < front_buffer.height; y++ { + same := true + line_offset := y * front_buffer.width + for x := 0; x < front_buffer.width; x++ { + cell_offset := line_offset + x + back := &back_buffer.cells[cell_offset] + front := &front_buffer.cells[cell_offset] + if *back != *front { + same = false + break + } + } + if same && diff.lines > 0 { + diffbuf = append(diffbuf, diff) + diff = diff_msg{} + } + if !same { + beg := len(charbuf) + end := beg + append_diff_line(y) + if diff.lines == 0 { + diff.pos = short(y) + gbeg = beg + } + diff.lines++ + diff.chars = charbuf[gbeg:end] + } + } + if diff.lines > 0 { + diffbuf = append(diffbuf, diff) + diff = diff_msg{} + } +} + +func cell_to_char_info(c Cell) (attr word, wc [2]wchar) { + attr = color_table_fg[c.Fg&0x0F] | color_table_bg[c.Bg&0x0F] + if c.Fg&AttrReverse|c.Bg&AttrReverse != 0 { + attr = (attr&0xF0)>>4 | (attr&0x0F)<<4 + } + if c.Fg&AttrBold != 0 { + attr |= foreground_intensity + } + if c.Bg&AttrBold != 0 { + attr |= background_intensity + } + + r0, r1 := utf16.EncodeRune(c.Ch) + if r0 == 0xFFFD { + wc[0] = wchar(c.Ch) + wc[1] = ' ' + } else { + wc[0] = wchar(r0) + wc[1] = wchar(r1) + } + return +} + +func move_cursor(x, y int) { + err := set_console_cursor_position(out, coord{short(x), short(y)}) + if err != nil { + panic(err) + } +} + +func show_cursor(visible bool) { + var v int32 + if visible { + v = 1 + } + + var info console_cursor_info + info.size = 100 + info.visible = v + err := set_console_cursor_info(out, &info) + if err != nil { + panic(err) + } +} + +func clear() { + var err error + attr, char := cell_to_char_info(Cell{ + ' ', + foreground, + background, + }) + + area := int(term_size.x) * int(term_size.y) + err = fill_console_output_attribute(out, attr, area) + if err != nil { + panic(err) + } + err = fill_console_output_character(out, char[0], area) + if err != nil { + panic(err) + } + if !is_cursor_hidden(cursor_x, cursor_y) { + move_cursor(cursor_x, cursor_y) + } +} + +func key_event_record_to_event(r *key_event_record) (Event, bool) { + if r.key_down == 0 { + return Event{}, false + } + + e := Event{Type: EventKey} + if input_mode&InputAlt != 0 { + if alt_mode_esc { + e.Mod = ModAlt + alt_mode_esc = false + } + if r.control_key_state&(left_alt_pressed|right_alt_pressed) != 0 { + e.Mod = ModAlt + } + } + + ctrlpressed := r.control_key_state&(left_ctrl_pressed|right_ctrl_pressed) != 0 + + if r.virtual_key_code >= vk_f1 && r.virtual_key_code <= vk_f12 { + switch r.virtual_key_code { + case vk_f1: + e.Key = KeyF1 + case vk_f2: + e.Key = KeyF2 + case vk_f3: + e.Key = KeyF3 + case vk_f4: + e.Key = KeyF4 + case vk_f5: + e.Key = KeyF5 + case vk_f6: + e.Key = KeyF6 + case vk_f7: + e.Key = KeyF7 + case vk_f8: + e.Key = KeyF8 + case vk_f9: + e.Key = KeyF9 + case vk_f10: + e.Key = KeyF10 + case vk_f11: + e.Key = KeyF11 + case vk_f12: + e.Key = KeyF12 + default: + panic("unreachable") + } + + return e, true + } + + if r.virtual_key_code <= vk_delete { + switch r.virtual_key_code { + case vk_insert: + e.Key = KeyInsert + case vk_delete: + e.Key = KeyDelete + case vk_home: + e.Key = KeyHome + case vk_end: + e.Key = KeyEnd + case vk_pgup: + e.Key = KeyPgup + case vk_pgdn: + e.Key = KeyPgdn + case vk_arrow_up: + e.Key = KeyArrowUp + case vk_arrow_down: + e.Key = KeyArrowDown + case vk_arrow_left: + e.Key = KeyArrowLeft + case vk_arrow_right: + e.Key = KeyArrowRight + case vk_backspace: + if ctrlpressed { + e.Key = KeyBackspace2 + } else { + e.Key = KeyBackspace + } + case vk_tab: + e.Key = KeyTab + case vk_enter: + e.Key = KeyEnter + case vk_esc: + switch { + case input_mode&InputEsc != 0: + e.Key = KeyEsc + case input_mode&InputAlt != 0: + alt_mode_esc = true + return Event{}, false + } + case vk_space: + if ctrlpressed { + // manual return here, because KeyCtrlSpace is zero + e.Key = KeyCtrlSpace + return e, true + } else { + e.Key = KeySpace + } + } + + if e.Key != 0 { + return e, true + } + } + + if ctrlpressed { + if Key(r.unicode_char) >= KeyCtrlA && Key(r.unicode_char) <= KeyCtrlRsqBracket { + e.Key = Key(r.unicode_char) + if input_mode&InputAlt != 0 && e.Key == KeyEsc { + alt_mode_esc = true + return Event{}, false + } + return e, true + } + switch r.virtual_key_code { + case 192, 50: + // manual return here, because KeyCtrl2 is zero + e.Key = KeyCtrl2 + return e, true + case 51: + if input_mode&InputAlt != 0 { + alt_mode_esc = true + return Event{}, false + } + e.Key = KeyCtrl3 + case 52: + e.Key = KeyCtrl4 + case 53: + e.Key = KeyCtrl5 + case 54: + e.Key = KeyCtrl6 + case 189, 191, 55: + e.Key = KeyCtrl7 + case 8, 56: + e.Key = KeyCtrl8 + } + + if e.Key != 0 { + return e, true + } + } + + if r.unicode_char != 0 { + e.Ch = rune(r.unicode_char) + return e, true + } + + return Event{}, false +} + +func input_event_producer() { + var r input_record + var err error + var last_button Key + var last_state = dword(0) + handles := []syscall.Handle{in, interrupt} + for { + err = wait_for_multiple_objects(handles) + if err != nil { + input_comm <- Event{Type: EventError, Err: err} + } + + select { + case <-cancel_comm: + cancel_done_comm <- true + return + default: + } + + err = read_console_input(in, &r) + if err != nil { + input_comm <- Event{Type: EventError, Err: err} + } + + switch r.event_type { + case key_event: + kr := (*key_event_record)(unsafe.Pointer(&r.event)) + ev, ok := key_event_record_to_event(kr) + if ok { + for i := 0; i < int(kr.repeat_count); i++ { + input_comm <- ev + } + } + case window_buffer_size_event: + sr := *(*window_buffer_size_record)(unsafe.Pointer(&r.event)) + input_comm <- Event{ + Type: EventResize, + Width: int(sr.size.x), + Height: int(sr.size.y), + } + case mouse_event: + mr := *(*mouse_event_record)(unsafe.Pointer(&r.event)) + + // single or double click + switch mr.event_flags { + case 0: + cur_state := mr.button_state + switch { + case last_state&mouse_lmb == 0 && cur_state&mouse_lmb != 0: + last_button = MouseLeft + case last_state&mouse_rmb == 0 && cur_state&mouse_rmb != 0: + last_button = MouseRight + case last_state&mouse_mmb == 0 && cur_state&mouse_mmb != 0: + last_button = MouseMiddle + default: + last_state = cur_state + continue + } + last_state = cur_state + fallthrough + case 2: + input_comm <- Event{ + Type: EventMouse, + Key: last_button, + MouseX: int(mr.mouse_pos.x), + MouseY: int(mr.mouse_pos.y), + } + } + } + } +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/terminfo.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/terminfo.go new file mode 100644 index 000000000..3569e3c0e --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/terminfo.go @@ -0,0 +1,219 @@ +// +build !windows +// This file contains a simple and incomplete implementation of the terminfo +// database. Information was taken from the ncurses manpages term(5) and +// terminfo(5). Currently, only the string capabilities for special keys and for +// functions without parameters are actually used. Colors are still done with +// ANSI escape sequences. Other special features that are not (yet?) supported +// are reading from ~/.terminfo, the TERMINFO_DIRS variable, Berkeley database +// format and extended capabilities. + +package termbox + +import ( + "bytes" + "encoding/binary" + "encoding/hex" + "errors" + "fmt" + "io/ioutil" + "os" + "strings" +) + +const ( + ti_magic = 0432 + ti_header_length = 12 +) + +func load_terminfo() ([]byte, error) { + var data []byte + var err error + + term := os.Getenv("TERM") + if term == "" { + return nil, fmt.Errorf("termbox: TERM not set") + } + + // The following behaviour follows the one described in terminfo(5) as + // distributed by ncurses. + + terminfo := os.Getenv("TERMINFO") + if terminfo != "" { + // if TERMINFO is set, no other directory should be searched + return ti_try_path(terminfo) + } + + // next, consider ~/.terminfo + home := os.Getenv("HOME") + if home != "" { + data, err = ti_try_path(home + "/.terminfo") + if err == nil { + return data, nil + } + } + + // next, TERMINFO_DIRS + dirs := os.Getenv("TERMINFO_DIRS") + if dirs != "" { + for _, dir := range strings.Split(dirs, ":") { + if dir == "" { + // "" -> "/usr/share/terminfo" + dir = "/usr/share/terminfo" + } + data, err = ti_try_path(dir) + if err == nil { + return data, nil + } + } + } + + // fall back to /usr/share/terminfo + return ti_try_path("/usr/share/terminfo") +} + +func ti_try_path(path string) (data []byte, err error) { + // load_terminfo already made sure it is set + term := os.Getenv("TERM") + + // first try, the typical *nix path + terminfo := path + "/" + term[0:1] + "/" + term + data, err = ioutil.ReadFile(terminfo) + if err == nil { + return + } + + // fallback to darwin specific dirs structure + terminfo = path + "/" + hex.EncodeToString([]byte(term[:1])) + "/" + term + data, err = ioutil.ReadFile(terminfo) + return +} + +func setup_term_builtin() error { + name := os.Getenv("TERM") + if name == "" { + return errors.New("termbox: TERM environment variable not set") + } + + for _, t := range terms { + if t.name == name { + keys = t.keys + funcs = t.funcs + return nil + } + } + + compat_table := []struct { + partial string + keys []string + funcs []string + }{ + {"xterm", xterm_keys, xterm_funcs}, + {"rxvt", rxvt_unicode_keys, rxvt_unicode_funcs}, + {"linux", linux_keys, linux_funcs}, + {"Eterm", eterm_keys, eterm_funcs}, + {"screen", screen_keys, screen_funcs}, + // let's assume that 'cygwin' is xterm compatible + {"cygwin", xterm_keys, xterm_funcs}, + {"st", xterm_keys, xterm_funcs}, + } + + // try compatibility variants + for _, it := range compat_table { + if strings.Contains(name, it.partial) { + keys = it.keys + funcs = it.funcs + return nil + } + } + + return errors.New("termbox: unsupported terminal") +} + +func setup_term() (err error) { + var data []byte + var header [6]int16 + var str_offset, table_offset int16 + + data, err = load_terminfo() + if err != nil { + return setup_term_builtin() + } + + rd := bytes.NewReader(data) + // 0: magic number, 1: size of names section, 2: size of boolean section, 3: + // size of numbers section (in integers), 4: size of the strings section (in + // integers), 5: size of the string table + + err = binary.Read(rd, binary.LittleEndian, header[:]) + if err != nil { + return + } + + if (header[1]+header[2])%2 != 0 { + // old quirk to align everything on word boundaries + header[2] += 1 + } + str_offset = ti_header_length + header[1] + header[2] + 2*header[3] + table_offset = str_offset + 2*header[4] + + keys = make([]string, 0xFFFF-key_min) + for i, _ := range keys { + keys[i], err = ti_read_string(rd, str_offset+2*ti_keys[i], table_offset) + if err != nil { + return + } + } + funcs = make([]string, t_max_funcs) + // the last two entries are reserved for mouse. because the table offset is + // not there, the two entries have to fill in manually + for i, _ := range funcs[:len(funcs)-2] { + funcs[i], err = ti_read_string(rd, str_offset+2*ti_funcs[i], table_offset) + if err != nil { + return + } + } + funcs[t_max_funcs-2] = "\x1b[?1000h" + funcs[t_max_funcs-1] = "\x1b[?1000l" + return nil +} + +func ti_read_string(rd *bytes.Reader, str_off, table int16) (string, error) { + var off int16 + + _, err := rd.Seek(int64(str_off), 0) + if err != nil { + return "", err + } + err = binary.Read(rd, binary.LittleEndian, &off) + if err != nil { + return "", err + } + _, err = rd.Seek(int64(table+off), 0) + if err != nil { + return "", err + } + var bs []byte + for { + b, err := rd.ReadByte() + if err != nil { + return "", err + } + if b == byte(0x00) { + break + } + bs = append(bs, b) + } + return string(bs), nil +} + +// "Maps" the function constants from termbox.go to the number of the respective +// string capability in the terminfo file. Taken from (ncurses) term.h. +var ti_funcs = []int16{ + 28, 40, 16, 13, 5, 39, 36, 27, 26, 34, 89, 88, +} + +// Same as above for the special keys. +var ti_keys = []int16{ + 66, 68 /* apparently not a typo; 67 is F10 for whatever reason */, 69, 70, + 71, 72, 73, 74, 75, 67, 216, 217, 77, 59, 76, 164, 82, 81, 87, 61, 79, 83, +} diff --git a/Godeps/_workspace/src/github.com/nsf/termbox-go/terminfo_builtin.go b/Godeps/_workspace/src/github.com/nsf/termbox-go/terminfo_builtin.go new file mode 100644 index 000000000..6f927c852 --- /dev/null +++ b/Godeps/_workspace/src/github.com/nsf/termbox-go/terminfo_builtin.go @@ -0,0 +1,64 @@ +// +build !windows + +package termbox + +// Eterm +var eterm_keys = []string{ + "\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", +} +var eterm_funcs = []string{ + "\x1b7\x1b[?47h", "\x1b[2J\x1b[?47l\x1b8", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "", "", "", "", +} + +// screen +var screen_keys = []string{ + "\x1bOP", "\x1bOQ", "\x1bOR", "\x1bOS", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[1~", "\x1b[4~", "\x1b[5~", "\x1b[6~", "\x1bOA", "\x1bOB", "\x1bOD", "\x1bOC", +} +var screen_funcs = []string{ + "\x1b[?1049h", "\x1b[?1049l", "\x1b[34h\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b[?1h\x1b=", "\x1b[?1l\x1b>", "\x1b[?1000h", "\x1b[?1000l", +} + +// xterm +var xterm_keys = []string{ + "\x1bOP", "\x1bOQ", "\x1bOR", "\x1bOS", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1bOH", "\x1bOF", "\x1b[5~", "\x1b[6~", "\x1bOA", "\x1bOB", "\x1bOD", "\x1bOC", +} +var xterm_funcs = []string{ + "\x1b[?1049h", "\x1b[?1049l", "\x1b[?12l\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b(B\x1b[m", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b[?1h\x1b=", "\x1b[?1l\x1b>", "\x1b[?1000h", "\x1b[?1000l", +} + +// rxvt-unicode +var rxvt_unicode_keys = []string{ + "\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", +} +var rxvt_unicode_funcs = []string{ + "\x1b[?1049h", "\x1b[r\x1b[?1049l", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x1b(B", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b=", "\x1b>", "\x1b[?1000h", "\x1b[?1000l", +} + +// linux +var linux_keys = []string{ + "\x1b[[A", "\x1b[[B", "\x1b[[C", "\x1b[[D", "\x1b[[E", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[1~", "\x1b[4~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", +} +var linux_funcs = []string{ + "", "", "\x1b[?25h\x1b[?0c", "\x1b[?25l\x1b[?1c", "\x1b[H\x1b[J", "\x1b[0;10m", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "", "", "", "", +} + +// rxvt-256color +var rxvt_256color_keys = []string{ + "\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", +} +var rxvt_256color_funcs = []string{ + "\x1b7\x1b[?47h", "\x1b[2J\x1b[?47l\x1b8", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b=", "\x1b>", "\x1b[?1000h", "\x1b[?1000l", +} + +var terms = []struct { + name string + keys []string + funcs []string +}{ + {"Eterm", eterm_keys, eterm_funcs}, + {"screen", screen_keys, screen_funcs}, + {"xterm", xterm_keys, xterm_funcs}, + {"rxvt-unicode", rxvt_unicode_keys, rxvt_unicode_funcs}, + {"linux", linux_keys, linux_funcs}, + {"rxvt-256color", rxvt_256color_keys, rxvt_256color_funcs}, +} diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/.gitignore b/Godeps/_workspace/src/github.com/obscuren/qml/.gitignore deleted file mode 100644 index e4b7f45b7..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -examples/qmlscene/qmlscene -examples/snapweb/snapweb -examples/particle/particle -gl/gengl/gengl -*.swp diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/LICENSE b/Godeps/_workspace/src/github.com/obscuren/qml/LICENSE deleted file mode 100644 index 53320c352..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/LICENSE +++ /dev/null @@ -1,185 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/README.md b/Godeps/_workspace/src/github.com/obscuren/qml/README.md deleted file mode 100644 index e969c9e1d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/README.md +++ /dev/null @@ -1,157 +0,0 @@ -# QML support for the Go language - -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/Godeps/_workspace/src/github.com/obscuren/qml/all.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/all.cpp deleted file mode 100644 index 965867b1b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/all.cpp +++ /dev/null @@ -1,12 +0,0 @@ - -#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/Godeps/_workspace/src/github.com/obscuren/qml/bridge.go b/Godeps/_workspace/src/github.com/obscuren/qml/bridge.go deleted file mode 100644 index 77b36a566..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/bridge.go +++ /dev/null @@ -1,681 +0,0 @@ -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 -} - -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(unsafe.Pointer(fold), 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, specp unsafe.Pointer) (foldp unsafe.Pointer) { - // Initialization is postponed until the engine is available, so that - // we can hand Init the qml.Object that represents the object. - init := reflect.ValueOf((*TypeSpec)(specp).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 unsafe.Pointer(fold) -} - -//export hookGoValueDestroyed -func hookGoValueDestroyed(enginep unsafe.Pointer, foldp unsafe.Pointer) { - fold := (*valueFold)(foldp) - engine := fold.engine - if engine == nil { - before := len(typeNew) - delete(typeNew, fold) - 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) - } - } - } - //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, foldp unsafe.Pointer, reflectIndex, getIndex, setIndex C.int, resultdv *C.DataValue) { - fold := ensureEngine(enginep, foldp) - - 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(foldp, 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, foldp unsafe.Pointer, reflectIndex, setIndex C.int, assigndv *C.DataValue) { - fold := ensureEngine(enginep, foldp) - 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, foldp unsafe.Pointer, reflectIndex C.int, args *C.DataValue) { - fold := ensureEngine(enginep, foldp) - 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, foldp unsafe.Pointer, 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, foldp) - 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, foldp unsafe.Pointer) *valueFold { - fold := (*valueFold)(foldp) - 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(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, index C.int) (objp unsafe.Pointer) { - fold := (*valueFold)(foldp) - slice := listSlice(fold, reflectIndex) - return (*slice)[int(index)].Common().addr -} - -//export hookListPropertyCount -func hookListPropertyCount(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t) C.int { - fold := (*valueFold)(foldp) - slice := listSlice(fold, reflectIndex) - return C.int(len(*slice)) -} - -//export hookListPropertyAppend -func hookListPropertyAppend(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, objp unsafe.Pointer) { - fold := (*valueFold)(foldp) - 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(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t) { - fold := (*valueFold)(foldp) - 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/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata.go b/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata.go deleted file mode 100644 index 6f13b810f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata.go +++ /dev/null @@ -1,6 +0,0 @@ -// Package cdata supports the implementation of the qml package. -package cdata - -func Ref() uintptr - -func Addrs() (uintptr, uintptr) diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata12.c b/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata12.c deleted file mode 100644 index 2e60abfa2..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata12.c +++ /dev/null @@ -1,18 +0,0 @@ -// +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/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_386.s b/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_386.s deleted file mode 100644 index 7dae9b961..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_386.s +++ /dev/null @@ -1,17 +0,0 @@ -// +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/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_amd64.s b/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_amd64.s deleted file mode 100644 index 83cc22c9c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_amd64.s +++ /dev/null @@ -1,17 +0,0 @@ -// +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/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_arm.s b/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_arm.s deleted file mode 100644 index c66bbafbf..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata14_arm.s +++ /dev/null @@ -1,18 +0,0 @@ -// +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/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata_test.go b/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata_test.go deleted file mode 100644 index e7c3f33c5..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cdata/cdata_test.go +++ /dev/null @@ -1,42 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/cmd/genqrc/main.go b/Godeps/_workspace/src/github.com/obscuren/qml/cmd/genqrc/main.go deleted file mode 100644 index a601d8126..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cmd/genqrc/main.go +++ /dev/null @@ -1,218 +0,0 @@ - -// 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/Godeps/_workspace/src/github.com/obscuren/qml/cmd/ubuntu-touch/particle.desktop b/Godeps/_workspace/src/github.com/obscuren/qml/cmd/ubuntu-touch/particle.desktop deleted file mode 100644 index 76a62cb50..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cmd/ubuntu-touch/particle.desktop +++ /dev/null @@ -1,15 +0,0 @@ -[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/Godeps/_workspace/src/github.com/obscuren/qml/cmd/ubuntu-touch/setup.sh b/Godeps/_workspace/src/github.com/obscuren/qml/cmd/ubuntu-touch/setup.sh deleted file mode 100644 index 1d0454110..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cmd/ubuntu-touch/setup.sh +++ /dev/null @@ -1,41 +0,0 @@ -#!/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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/capi.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/capi.cpp deleted file mode 100644 index 024e5ec9c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/capi.cpp +++ /dev/null @@ -1,884 +0,0 @@ -#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, void *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 *objectGoAddr(QObject_ *object, GoAddr **addr) -{ - QObject *qobject = static_cast(object); - GoValue *goValue = dynamic_cast(qobject); - if (goValue) { - *addr = goValue->addr; - return 0; - } - GoPaintedValue *goPaintedValue = dynamic_cast(qobject); - if (goPaintedValue) { - *addr = goPaintedValue->addr; - 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(GoAddr *addr, GoTypeInfo *typeInfo, QObject_ *parent) -{ - QObject *qparent = reinterpret_cast(parent); - if (typeInfo->paint) { - return new GoPaintedValue(addr, typeInfo, qparent); - } - return new GoValue(addr, 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; - case QMetaType::User: - { - static const int qjstype = QVariant::fromValue(QJSValue()).userType(); - if (qvar->userType() == qjstype) { - auto var = qvar->value().toVariant(); - packDataValue(&var, value); - } - } - break; - default: - if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert()) { - QObject *qobject = qvar->value(); - GoValue *goValue = dynamic_cast(qobject); - if (goValue) { - value->dataType = DTGoAddr; - *(void **)(value->data) = goValue->addr; - break; - } - GoPaintedValue *goPaintedValue = dynamic_cast(qobject); - if (goPaintedValue) { - value->dataType = DTGoAddr; - *(void **)(value->data) = goPaintedValue->addr; - 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(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2, i)); -} - -int listPropertyCount(QQmlListProperty *list) -{ - return hookListPropertyCount(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2); -} - -void listPropertyAppend(QQmlListProperty *list, QObject *obj) -{ - hookListPropertyAppend(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2, obj); -} - -void listPropertyClear(QQmlListProperty *list) -{ - hookListPropertyClear(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2); -} - -QQmlListProperty_ *newListProperty(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex) -{ - QQmlListProperty *list = new QQmlListProperty(); - list->data = addr; - 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) -{ - if (context.file == NULL) return; - - QByteArray textba = text.toUtf8(); - LogMessage message = {severity, textba.constData(), textba.size(), context.file, (int)strlen(context.file), 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/capi.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/capi.h deleted file mode 100644 index 25218637d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/capi.h +++ /dev/null @@ -1,211 +0,0 @@ -#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 void 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, void *func, int argsLen); -error *objectGoAddr(QObject_ *object, GoAddr **addr); - -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(GoAddr *addr, 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(GoAddr *addr, 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, GoAddr *addr, int memberIndex, int getIndex, int setIndex, DataValue *result); -void hookGoValueWriteField(QQmlEngine_ *engine, GoAddr *addr, int memberIndex, int setIndex, DataValue *assign); -void hookGoValueCallMethod(QQmlEngine_ *engine, GoAddr *addr, int memberIndex, DataValue *result); -void hookGoValueDestroyed(QQmlEngine_ *engine, GoAddr *addr); -void hookGoValuePaint(QQmlEngine_ *engine, GoAddr *addr, intptr_t reflextIndex); -QImage_ *hookRequestImage(void *imageFunc, char *id, int idLen, int width, int height); -GoAddr *hookGoValueTypeNew(GoValue_ *value, GoTypeSpec_ *spec); -void hookWindowHidden(QObject_ *addr); -void hookSignalCall(QQmlEngine_ *engine, void *func, DataValue *params); -void hookSignalDisconnect(void *func); -void hookPanic(char *message); -int hookListPropertyCount(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex); -QObject_ *hookListPropertyAt(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex, int i); -void hookListPropertyAppend(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex, QObject_ *obj); -void hookListPropertyClear(GoAddr *addr, 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/connector.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/connector.cpp deleted file mode 100644 index 6005bfc62..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/connector.cpp +++ /dev/null @@ -1,46 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/connector.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/connector.h deleted file mode 100644 index 82954927b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/connector.h +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef CONNECTOR_H -#define CONNECTOR_H - -#include - -#include - -class Connector : public QObject -{ - Q_OBJECT - - public: - - Connector(QObject *sender, QMetaMethod method, QQmlEngine *engine, void *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; - void *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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govalue.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govalue.cpp deleted file mode 100644 index 5cf58a62d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govalue.cpp +++ /dev/null @@ -1,236 +0,0 @@ -#include - -#include -#include - -#include -#include -#include - -#include "govalue.h" -#include "capi.h" - -class GoValueMetaObject : public QAbstractDynamicMetaObject -{ -public: - GoValueMetaObject(QObject* value, GoAddr *addr, GoTypeInfo *typeInfo); - - void activatePropIndex(int propIndex); - -protected: - int metaCall(QMetaObject::Call c, int id, void **a); - -private: - QObject *value; - GoAddr *addr; - GoTypeInfo *typeInfo; -}; - -GoValueMetaObject::GoValueMetaObject(QObject *value, GoAddr *addr, GoTypeInfo *typeInfo) - : value(value), addr(addr), 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), addr, 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), addr, 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), addr, 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(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent) - : addr(addr), typeInfo(typeInfo) -{ - valueMeta = new GoValueMetaObject(this, addr, typeInfo); - setParent(parent); -} - -GoValue::~GoValue() -{ - hookGoValueDestroyed(qmlEngine(this), addr); -} - -void GoValue::activate(int propIndex) -{ - valueMeta->activatePropIndex(propIndex); -} - -GoPaintedValue::GoPaintedValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent) - : addr(addr), typeInfo(typeInfo) -{ - valueMeta = new GoValueMetaObject(this, addr, typeInfo); - setParent(parent); - - QQuickItem::setFlag(QQuickItem::ItemHasContents, true); - QQuickPaintedItem::setRenderTarget(QQuickPaintedItem::FramebufferObject); -} - -GoPaintedValue::~GoPaintedValue() -{ - hookGoValueDestroyed(qmlEngine(this), addr); -} - -void GoPaintedValue::activate(int propIndex) -{ - valueMeta->activatePropIndex(propIndex); -} - -void GoPaintedValue::paint(QPainter *painter) -{ - painter->beginNativePainting(); - hookGoValuePaint(qmlEngine(this), addr, 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govalue.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govalue.h deleted file mode 100644 index aa6ddd10c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govalue.h +++ /dev/null @@ -1,56 +0,0 @@ -#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: - GoAddr *addr; - GoTypeInfo *typeInfo; - - GoValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent); - virtual ~GoValue(); - - void activate(int propIndex); - -private: - GoValueMetaObject *valueMeta; -}; - -class GoPaintedValue : public QQuickPaintedItem -{ - Q_OBJECT - -public: - GoAddr *addr; - GoTypeInfo *typeInfo; - - GoPaintedValue(GoAddr *addr, 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govaluetype.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govaluetype.cpp deleted file mode 100644 index 925045390..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govaluetype.cpp +++ /dev/null @@ -1,254 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govaluetype.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govaluetype.h deleted file mode 100644 index 6007d394c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/govaluetype.h +++ /dev/null @@ -1,48 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/idletimer.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/idletimer.cpp deleted file mode 100644 index 3bd097508..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/idletimer.cpp +++ /dev/null @@ -1,58 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/mmemwin.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/mmemwin.cpp deleted file mode 100644 index 7aa3bff2b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/mmemwin.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_all.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_all.cpp deleted file mode 100644 index cff097058..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_all.cpp +++ /dev/null @@ -1,4 +0,0 @@ -// 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_connector.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_connector.cpp deleted file mode 100644 index 2de2d827a..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_connector.cpp +++ /dev/null @@ -1,211 +0,0 @@ -/**************************************************************************** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_govalue.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_govalue.cpp deleted file mode 100644 index e41f86042..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_govalue.cpp +++ /dev/null @@ -1,155 +0,0 @@ -/**************************************************************************** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_idletimer.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_idletimer.cpp deleted file mode 100644 index 98dda16e3..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/moc_idletimer.cpp +++ /dev/null @@ -1,108 +0,0 @@ -/**************************************************************************** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qmetaobject_p.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qmetaobject_p.h deleted file mode 100644 index af506e54f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qmetaobject_p.h +++ /dev/null @@ -1,2 +0,0 @@ -#include "private/qtheader.h" -#include QT_PRIVATE_HEADER(QtCore,qmetaobject_p.h) diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qmetaobjectbuilder_p.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qmetaobjectbuilder_p.h deleted file mode 100644 index 47cd9b77f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qmetaobjectbuilder_p.h +++ /dev/null @@ -1,2 +0,0 @@ -#include "private/qtheader.h" -#include QT_PRIVATE_HEADER(QtCore,qmetaobjectbuilder_p.h) diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qobject_p.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qobject_p.h deleted file mode 100644 index 75c7f84b4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qobject_p.h +++ /dev/null @@ -1,2 +0,0 @@ -#include "private/qtheader.h" -#include QT_PRIVATE_HEADER(QtCore,qobject_p.h) diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qtheader.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qtheader.h deleted file mode 100644 index efa8b87c4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/private/qtheader.h +++ /dev/null @@ -1,70 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpp/update-moc.sh b/Godeps/_workspace/src/github.com/obscuren/qml/cpp/update-moc.sh deleted file mode 100644 index 135840f45..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpp/update-moc.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/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/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.cpp deleted file mode 100644 index e0b25699f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.cpp +++ /dev/null @@ -1,14 +0,0 @@ -#include - -#include "cpptest.h" -#include "testtype.h" - -TestType_ *newTestType() -{ - return new TestType(); -} - -int plainTestTypeN(PlainTestType_ *plain) -{ - return static_cast(plain)->n; -} diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.go b/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.go deleted file mode 100644 index 4ba24bce0..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.go +++ /dev/null @@ -1,30 +0,0 @@ -// 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/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.h deleted file mode 100644 index e06a8af3f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/cpptest.h +++ /dev/null @@ -1,23 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/moc_testtype.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/moc_testtype.cpp deleted file mode 100644 index f958d1b8c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/moc_testtype.cpp +++ /dev/null @@ -1,202 +0,0 @@ -/**************************************************************************** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/testtype.h b/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/testtype.h deleted file mode 100644 index 4d281b98f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/testtype.h +++ /dev/null @@ -1,45 +0,0 @@ -#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/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/update-moc.sh b/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/update-moc.sh deleted file mode 100644 index 9abbfdf2b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/cpptest/update-moc.sh +++ /dev/null @@ -1,12 +0,0 @@ -#!/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/Godeps/_workspace/src/github.com/obscuren/qml/datatype.go b/Godeps/_workspace/src/github.com/obscuren/qml/datatype.go deleted file mode 100644 index 875c54622..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/datatype.go +++ /dev/null @@ -1,531 +0,0 @@ -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 := (*(**valueFold)(datap)) - ensureEngine(engine.addr, unsafe.Pointer(fold)) - 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/Godeps/_workspace/src/github.com/obscuren/qml/doc.go b/Godeps/_workspace/src/github.com/obscuren/qml/doc.go deleted file mode 100644 index 94b2404a9..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/doc.go +++ /dev/null @@ -1,199 +0,0 @@ -// 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/.gitignore b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/.gitignore deleted file mode 100644 index 309fbb35d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -basiclayouts/basiclayouts -gallery/gallery -splitview/splitview -tableview/tableview -touch/touch diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/README.md b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/README.md deleted file mode 100644 index 201846d89..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/README.md +++ /dev/null @@ -1,8 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/basiclayouts/basiclayouts.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/basiclayouts/basiclayouts.go deleted file mode 100644 index a16b6b1ab..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/basiclayouts/basiclayouts.go +++ /dev/null @@ -1,29 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/basiclayouts/main.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/basiclayouts/main.qml deleted file mode 100644 index ecbbb75a1..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/basiclayouts/main.qml +++ /dev/null @@ -1,116 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/AboutDialog.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/AboutDialog.qml deleted file mode 100644 index aec7b6043..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/AboutDialog.qml +++ /dev/null @@ -1,48 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ChildWindow.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ChildWindow.qml deleted file mode 100644 index 08925f632..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ChildWindow.qml +++ /dev/null @@ -1,122 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Controls.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Controls.qml deleted file mode 100644 index b7e461881..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Controls.qml +++ /dev/null @@ -1,229 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ImageViewer.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ImageViewer.qml deleted file mode 100644 index 01f24ab33..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ImageViewer.qml +++ /dev/null @@ -1,58 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Layouts.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Layouts.qml deleted file mode 100644 index 0cb234c39..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Layouts.qml +++ /dev/null @@ -1,107 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ModelView.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ModelView.qml deleted file mode 100644 index be334458d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/ModelView.qml +++ /dev/null @@ -1,103 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Styles.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Styles.qml deleted file mode 100644 index ed237d82b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/content/Styles.qml +++ /dev/null @@ -1,387 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/gallery.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/gallery.go deleted file mode 100644 index a16b6b1ab..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/gallery.go +++ /dev/null @@ -1,29 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/bubble.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/bubble.png deleted file mode 100644 index 62aa1efe5..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/bubble.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/button-pressed.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/button-pressed.png deleted file mode 100644 index d64cdaa78..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/button-pressed.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/button.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/button.png deleted file mode 100644 index 8ab41cc80..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/button.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-open.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-open.png deleted file mode 100644 index f35f25835..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-open.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-open@2x.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-open@2x.png deleted file mode 100644 index 9fdbb6657..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-open@2x.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-save-as.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-save-as.png deleted file mode 100644 index 5c9f6b343..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-save-as.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-save-as@2x.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-save-as@2x.png deleted file mode 100644 index a15e34c92..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/document-save-as@2x.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/folder_new.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/folder_new.png deleted file mode 100644 index 8d8bb9bd7..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/folder_new.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/go-next.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/go-next.png deleted file mode 100644 index a68e2db77..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/go-next.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/go-previous.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/go-previous.png deleted file mode 100644 index c37bc0414..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/go-previous.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/preferences-system.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/preferences-system.png deleted file mode 100644 index 6e52db7cf..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/preferences-system.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/process-stop.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/process-stop.png deleted file mode 100644 index e7a8d1722..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/process-stop.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/progress-background.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/progress-background.png deleted file mode 100644 index 55a069dfc..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/progress-background.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/progress-fill.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/progress-fill.png deleted file mode 100644 index b588c9586..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/progress-fill.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/slider-handle.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/slider-handle.png deleted file mode 100644 index ac4d4a0d9..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/slider-handle.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/tab.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/tab.png deleted file mode 100644 index 74fefab78..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/tab.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/tab_selected.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/tab_selected.png deleted file mode 100644 index 665400ccf..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/tab_selected.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/textfield.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/textfield.png deleted file mode 100644 index 1d4a38ab3..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/textfield.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/toplevel_window.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/toplevel_window.png deleted file mode 100644 index 4dc6a8cee..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/toplevel_window.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/view-refresh.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/view-refresh.png deleted file mode 100644 index 606ea9eba..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/view-refresh.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/window-new.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/window-new.png deleted file mode 100644 index e091702e3..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/window-new.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/window-new@2x.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/window-new@2x.png deleted file mode 100644 index 36503018e..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/images/window-new@2x.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/main.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/main.qml deleted file mode 100644 index 7250bb313..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/gallery/main.qml +++ /dev/null @@ -1,266 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/splitview/main.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/splitview/main.qml deleted file mode 100644 index d93c74d3d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/splitview/main.qml +++ /dev/null @@ -1,82 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/splitview/splitview.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/splitview/splitview.go deleted file mode 100644 index a16b6b1ab..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/splitview/splitview.go +++ /dev/null @@ -1,29 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/images/header.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/images/header.png deleted file mode 100644 index dba664609..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/images/header.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/images/selectedrow.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/images/selectedrow.png deleted file mode 100644 index 71192ea4e..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/images/selectedrow.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/main.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/main.qml deleted file mode 100644 index 9fb361369..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/main.qml +++ /dev/null @@ -1,405 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/tableview.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/tableview.go deleted file mode 100644 index a16b6b1ab..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/tableview/tableview.go +++ /dev/null @@ -1,29 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/AndroidDelegate.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/AndroidDelegate.qml deleted file mode 100644 index 21ee8e680..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/AndroidDelegate.qml +++ /dev/null @@ -1,92 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ButtonPage.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ButtonPage.qml deleted file mode 100644 index 6058671c5..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ButtonPage.qml +++ /dev/null @@ -1,176 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ListPage.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ListPage.qml deleted file mode 100644 index 65dc99f51..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ListPage.qml +++ /dev/null @@ -1,82 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ProgressBarPage.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ProgressBarPage.qml deleted file mode 100644 index 019d72061..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/ProgressBarPage.qml +++ /dev/null @@ -1,114 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/SliderPage.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/SliderPage.qml deleted file mode 100644 index 95009e4f2..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/SliderPage.qml +++ /dev/null @@ -1,106 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/TabBarPage.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/TabBarPage.qml deleted file mode 100644 index c9bebccd3..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/TabBarPage.qml +++ /dev/null @@ -1,102 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/TextInputPage.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/TextInputPage.qml deleted file mode 100644 index 0eeea03a2..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/content/TextInputPage.qml +++ /dev/null @@ -1,106 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/NOTICE.txt b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/NOTICE.txt deleted file mode 100644 index 93a9afc8c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/NOTICE.txt +++ /dev/null @@ -1,2 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/button_default.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/button_default.png deleted file mode 100644 index 6d6cfd9ad..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/button_default.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/button_pressed.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/button_pressed.png deleted file mode 100644 index ab78b6ea3..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/button_pressed.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/navigation_next_item.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/navigation_next_item.png deleted file mode 100644 index 6665c9d85..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/navigation_next_item.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/navigation_previous_item.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/navigation_previous_item.png deleted file mode 100644 index f8be01197..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/navigation_previous_item.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/tab_selected.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/tab_selected.png deleted file mode 100644 index 2345f7a8e..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/tab_selected.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/tabs_standard.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/tabs_standard.png deleted file mode 100644 index 7140ab7b7..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/tabs_standard.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/textinput.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/textinput.png deleted file mode 100644 index b0256db2c..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/textinput.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/toolbar.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/toolbar.png deleted file mode 100644 index e9eba4c74..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/images/toolbar.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/main.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/main.qml deleted file mode 100644 index c794f7dcc..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/main.qml +++ /dev/null @@ -1,147 +0,0 @@ -/**************************************************************************** -** -** 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/touch.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/touch.go deleted file mode 100644 index a16b6b1ab..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/controls/touch/touch.go +++ /dev/null @@ -1,29 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/customtype/customtype.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/customtype/customtype.go deleted file mode 100644 index 1433d6ed8..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/customtype/customtype.go +++ /dev/null @@ -1,48 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/customtype/customtype.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/customtype/customtype.qml deleted file mode 100644 index 54f7aa046..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/customtype/customtype.qml +++ /dev/null @@ -1,5 +0,0 @@ -import GoExtensions 1.0 - -GoType { - text: "Happy " + GoSingleton.event + ", Go!" -} diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/gopher.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/gopher.go deleted file mode 100644 index 45f18789f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/gopher.go +++ /dev/null @@ -1,117 +0,0 @@ -package main - -import ( - "fmt" - "gopkg.in/qml.v1" - "gopkg.in/qml.v1/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/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/gopher.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/gopher.qml deleted file mode 100644 index 1f4be6dd4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/gopher.qml +++ /dev/null @@ -1,42 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/mix.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/mix.qml deleted file mode 100644 index 0a9541ffe..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/mix.qml +++ /dev/null @@ -1,68 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/README.md b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/README.md deleted file mode 100644 index 77af72910..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/README.md +++ /dev/null @@ -1,10 +0,0 @@ - -Author ------- - - * https://github.com/golang-samples/gopher-3d - -License -------- - - * http://creativecommons.org/licenses/by/3.0/deed.en diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.blend b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.blend deleted file mode 100644 index 89c92b0da..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.blend and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.mtl b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.mtl deleted file mode 100644 index 532f5dc6c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.mtl +++ /dev/null @@ -1,65 +0,0 @@ -# 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.obj b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.obj deleted file mode 100644 index 478a52be5..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/model/gopher.obj +++ /dev/null @@ -1,31375 +0,0 @@ -# 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/wavefront.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/wavefront.go deleted file mode 100644 index 964f8b830..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/gopher/wavefront.go +++ /dev/null @@ -1,280 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/imgprovider.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/imgprovider.go deleted file mode 100644 index 533a23b86..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/imgprovider.go +++ /dev/null @@ -1,43 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/imgprovider.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/imgprovider.qml deleted file mode 100644 index 0c5c747f0..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/imgprovider.qml +++ /dev/null @@ -1,5 +0,0 @@ -import QtQuick 2.0 - -Image { - source: "image://pwd/ubuntu-gopher.png" -} diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/ubuntu-gopher.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/ubuntu-gopher.png deleted file mode 100644 index 3f51d3798..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/imgprovider/ubuntu-gopher.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/modelview/delegate/delegate.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/modelview/delegate/delegate.go deleted file mode 100644 index 440fd229a..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/modelview/delegate/delegate.go +++ /dev/null @@ -1,53 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/modelview/delegate/delegate.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/modelview/delegate/delegate.qml deleted file mode 100644 index 4b37d31f6..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/modelview/delegate/delegate.qml +++ /dev/null @@ -1,17 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting-es2/painting.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting-es2/painting.go deleted file mode 100644 index 71f2d89a2..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting-es2/painting.go +++ /dev/null @@ -1,115 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting-es2/painting.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting-es2/painting.qml deleted file mode 100644 index 8c59fc351..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting-es2/painting.qml +++ /dev/null @@ -1,66 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting/painting.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting/painting.go deleted file mode 100644 index eda1e19f5..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting/painting.go +++ /dev/null @@ -1,64 +0,0 @@ -package main - -import ( - "fmt" - "os" - - "gopkg.in/qml.v1" - "gopkg.in/qml.v1/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/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting/painting.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting/painting.qml deleted file mode 100644 index 8c59fc351..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/painting/painting.qml +++ /dev/null @@ -1,66 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/main.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/main.go deleted file mode 100644 index 2a7ab865b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/main.go +++ /dev/null @@ -1,84 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/particle.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/particle.png deleted file mode 100644 index 5c83896d2..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/particle.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/particle.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/particle.qml deleted file mode 100644 index 1fd1f1c8b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/particle/particle.qml +++ /dev/null @@ -1,89 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/Cell.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/Cell.qml deleted file mode 100644 index 998a49242..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/Cell.qml +++ /dev/null @@ -1,20 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/qmlscene.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/qmlscene.go deleted file mode 100644 index 6124ac568..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/qmlscene.go +++ /dev/null @@ -1,33 +0,0 @@ -package main - -import ( - "fmt" - "gopkg.in/qml.v1" - "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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial1.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial1.qml deleted file mode 100644 index e42216e6a..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial1.qml +++ /dev/null @@ -1,17 +0,0 @@ -// 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial2.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial2.qml deleted file mode 100644 index aa64bc1aa..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial2.qml +++ /dev/null @@ -1,30 +0,0 @@ -// 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial3.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial3.qml deleted file mode 100644 index e5eabab10..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qmlscene/tutorial3.qml +++ /dev/null @@ -1,45 +0,0 @@ -// 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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/assets/particle.png b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/assets/particle.png deleted file mode 100644 index 5c83896d2..000000000 Binary files a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/assets/particle.png and /dev/null differ diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/assets/particle.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/assets/particle.qml deleted file mode 100644 index 2708a3dfc..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/assets/particle.qml +++ /dev/null @@ -1,89 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/main.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/main.go deleted file mode 100644 index a151cdb49..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/main.go +++ /dev/null @@ -1,86 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/qrc.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/qrc.go deleted file mode 100644 index 7002e67f5..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/qrcpacking/qrc.go +++ /dev/null @@ -1,58 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/base.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/base.qml deleted file mode 100644 index a77243e37..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/base.qml +++ /dev/null @@ -1,7 +0,0 @@ -import QtQuick 2.0 - -Rectangle { - width: 640 - height: 480 - color: "black" -} diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/rect.qml b/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/rect.qml deleted file mode 100644 index 21eda2fea..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/rect.qml +++ /dev/null @@ -1,8 +0,0 @@ -import QtQuick 2.0 - -Rectangle { - anchors.centerIn: parent - width: 50 - height: 50 - color: "red" -} diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/reparent.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/reparent.go deleted file mode 100644 index c1399f88c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/reparent/reparent.go +++ /dev/null @@ -1,37 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/examples/snapweb/snapweb.go b/Godeps/_workspace/src/github.com/obscuren/qml/examples/snapweb/snapweb.go deleted file mode 100644 index 53d1d6210..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/examples/snapweb/snapweb.go +++ /dev/null @@ -1,70 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/funcs.cpp deleted file mode 100644 index d7d9cf657..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/funcs.cpp +++ /dev/null @@ -1,1848 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/funcs.h deleted file mode 100644 index c016eec7b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/funcs.h +++ /dev/null @@ -1,347 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/gl.go deleted file mode 100644 index ce6c47ce4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.0/gl.go +++ /dev/null @@ -1,2528 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/funcs.cpp deleted file mode 100644 index 1c0f0adbd..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/funcs.cpp +++ /dev/null @@ -1,2022 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/funcs.h deleted file mode 100644 index f89c6a452..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/funcs.h +++ /dev/null @@ -1,376 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/gl.go deleted file mode 100644 index 268e1c083..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.1/gl.go +++ /dev/null @@ -1,2789 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/funcs.cpp deleted file mode 100644 index 328f40f85..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/funcs.cpp +++ /dev/null @@ -1,2250 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/funcs.h deleted file mode 100644 index 958c34935..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/funcs.h +++ /dev/null @@ -1,414 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/gl.go deleted file mode 100644 index a3f089e74..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.2/gl.go +++ /dev/null @@ -1,3152 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/funcs.cpp deleted file mode 100644 index 582d20907..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/funcs.cpp +++ /dev/null @@ -1,2526 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/funcs.h deleted file mode 100644 index 9d3944383..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/funcs.h +++ /dev/null @@ -1,460 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/gl.go deleted file mode 100644 index 6df8965a3..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.3/gl.go +++ /dev/null @@ -1,3571 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/funcs.cpp deleted file mode 100644 index 0aed105f5..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/funcs.cpp +++ /dev/null @@ -1,2790 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/funcs.h deleted file mode 100644 index ea657e080..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/funcs.h +++ /dev/null @@ -1,504 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/gl.go deleted file mode 100644 index 6ddbc2441..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.4/gl.go +++ /dev/null @@ -1,3892 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/funcs.cpp deleted file mode 100644 index 6158162fc..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/funcs.cpp +++ /dev/null @@ -1,2892 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/funcs.h deleted file mode 100644 index d971f2dc3..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/funcs.h +++ /dev/null @@ -1,521 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/gl.go deleted file mode 100644 index 463f66f40..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/1.5/gl.go +++ /dev/null @@ -1,4237 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/funcs.cpp deleted file mode 100644 index 622f59045..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/funcs.cpp +++ /dev/null @@ -1,3444 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/funcs.h deleted file mode 100644 index ffa1a2a83..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/funcs.h +++ /dev/null @@ -1,613 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/gl.go deleted file mode 100644 index 7bd1e1b52..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.0/gl.go +++ /dev/null @@ -1,6407 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/funcs.cpp deleted file mode 100644 index 6235d6e81..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/funcs.cpp +++ /dev/null @@ -1,3480 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/funcs.h deleted file mode 100644 index 399784504..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/funcs.h +++ /dev/null @@ -1,619 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/gl.go deleted file mode 100644 index 718d258a3..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/2.1/gl.go +++ /dev/null @@ -1,6652 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/funcs.cpp deleted file mode 100644 index 8d4262f9c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/funcs.cpp +++ /dev/null @@ -1,3966 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/funcs.h deleted file mode 100644 index 81db33a9b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/funcs.h +++ /dev/null @@ -1,700 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/gl.go deleted file mode 100644 index a8509aecd..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.0/gl.go +++ /dev/null @@ -1,7663 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/funcs.cpp deleted file mode 100644 index 7f9846760..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/funcs.cpp +++ /dev/null @@ -1,1422 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/funcs.h deleted file mode 100644 index b06680d6e..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/funcs.h +++ /dev/null @@ -1,276 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/gl.go deleted file mode 100644 index 495e07b3c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.1/gl.go +++ /dev/null @@ -1,4999 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/funcs.cpp deleted file mode 100644 index c35066eba..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/funcs.cpp +++ /dev/null @@ -1,4140 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/funcs.h deleted file mode 100644 index 17fa70e2e..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/funcs.h +++ /dev/null @@ -1,729 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/gl.go deleted file mode 100644 index 3cf74a01e..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2compat/gl.go +++ /dev/null @@ -1,7973 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/funcs.cpp deleted file mode 100644 index adacb68e1..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/funcs.cpp +++ /dev/null @@ -1,1530 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/funcs.h deleted file mode 100644 index b0a5c4da4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/funcs.h +++ /dev/null @@ -1,294 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/gl.go deleted file mode 100644 index 80805299a..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.2core/gl.go +++ /dev/null @@ -1,4729 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/funcs.cpp deleted file mode 100644 index 65c02b7de..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/funcs.cpp +++ /dev/null @@ -1,4488 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/funcs.h deleted file mode 100644 index bd7747532..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/funcs.h +++ /dev/null @@ -1,787 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/gl.go deleted file mode 100644 index 8772aa9bc..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3compat/gl.go +++ /dev/null @@ -1,8281 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/funcs.cpp deleted file mode 100644 index b03b94ac9..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/funcs.cpp +++ /dev/null @@ -1,1878 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/funcs.h deleted file mode 100644 index 77017a8c7..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/funcs.h +++ /dev/null @@ -1,352 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/gl.go deleted file mode 100644 index 13e2a4a94..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/3.3core/gl.go +++ /dev/null @@ -1,5489 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/funcs.cpp deleted file mode 100644 index 1dfaf3f0d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/funcs.cpp +++ /dev/null @@ -1,4764 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/funcs.h deleted file mode 100644 index e556b7357..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/funcs.h +++ /dev/null @@ -1,833 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/gl.go deleted file mode 100644 index 246afb061..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0compat/gl.go +++ /dev/null @@ -1,8607 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/funcs.cpp deleted file mode 100644 index 1be157d64..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/funcs.cpp +++ /dev/null @@ -1,2154 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/funcs.h deleted file mode 100644 index 55af051dc..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/funcs.h +++ /dev/null @@ -1,398 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/gl.go deleted file mode 100644 index ddfef9318..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.0core/gl.go +++ /dev/null @@ -1,5815 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/funcs.cpp deleted file mode 100644 index 70ec9e7f3..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/funcs.cpp +++ /dev/null @@ -1,5286 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/funcs.h deleted file mode 100644 index 3e583ce97..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/funcs.h +++ /dev/null @@ -1,920 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/gl.go deleted file mode 100644 index 3d4370205..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1compat/gl.go +++ /dev/null @@ -1,9201 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/funcs.cpp deleted file mode 100644 index 9ae51693c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/funcs.cpp +++ /dev/null @@ -1,2676 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/funcs.h deleted file mode 100644 index e582a112c..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/funcs.h +++ /dev/null @@ -1,485 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/gl.go deleted file mode 100644 index e5579001a..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.1core/gl.go +++ /dev/null @@ -1,6409 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/funcs.cpp deleted file mode 100644 index 6101e99de..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/funcs.cpp +++ /dev/null @@ -1,5358 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/funcs.h deleted file mode 100644 index 964194dcc..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/funcs.h +++ /dev/null @@ -1,932 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/gl.go deleted file mode 100644 index c91fbef65..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2compat/gl.go +++ /dev/null @@ -1,9386 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/funcs.cpp deleted file mode 100644 index 567e39b30..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/funcs.cpp +++ /dev/null @@ -1,2748 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/funcs.h deleted file mode 100644 index 969f03fdd..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/funcs.h +++ /dev/null @@ -1,497 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/gl.go deleted file mode 100644 index a452b7296..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.2core/gl.go +++ /dev/null @@ -1,6594 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/funcs.cpp deleted file mode 100644 index 04ab8fadd..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/funcs.cpp +++ /dev/null @@ -1,5556 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/funcs.h deleted file mode 100644 index ef3dac794..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/funcs.h +++ /dev/null @@ -1,965 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/gl.go deleted file mode 100644 index 4ee8a9ef6..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3compat/gl.go +++ /dev/null @@ -1,9845 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/funcs.cpp deleted file mode 100644 index fec3ebd31..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/funcs.cpp +++ /dev/null @@ -1,2946 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/funcs.h deleted file mode 100644 index b65f69bc4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/funcs.h +++ /dev/null @@ -1,530 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/gl.go deleted file mode 100644 index 76df4604f..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/4.3core/gl.go +++ /dev/null @@ -1,7052 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/funcs.cpp b/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/funcs.cpp deleted file mode 100644 index 71acf8d1b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/funcs.cpp +++ /dev/null @@ -1,813 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/funcs.h b/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/funcs.h deleted file mode 100644 index 7e9fd3534..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/funcs.h +++ /dev/null @@ -1,182 +0,0 @@ - -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/gl.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/gl.go deleted file mode 100644 index 82c9d77cf..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/es2/gl.go +++ /dev/null @@ -1,2990 +0,0 @@ -// ** 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/Makefile b/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/Makefile deleted file mode 100644 index f814cceb1..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/Makefile +++ /dev/null @@ -1,9 +0,0 @@ - -gengl: main.go parseqt.go - go build - -%.go: %.rl - ragel -Z -G2 -o $@ $< - -run: gengl - ./gengl diff --git a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/funcs.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/funcs.go deleted file mode 100644 index 994a3e91b..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/funcs.go +++ /dev/null @@ -1,1764 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/gl.xml b/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/gl.xml deleted file mode 100644 index d5c920237..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/gl.xml +++ /dev/null @@ -1,43891 +0,0 @@ - - - -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/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/main.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/main.go deleted file mode 100644 index e92e861f7..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/main.go +++ /dev/null @@ -1,1283 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/parseqt.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/parseqt.go deleted file mode 100644 index a4a882dd9..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/parseqt.go +++ /dev/null @@ -1,13904 +0,0 @@ - -// 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/parseqt.rl b/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/parseqt.rl deleted file mode 100644 index 4aa4a1345..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/gengl/parseqt.rl +++ /dev/null @@ -1,184 +0,0 @@ -// -// 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/Godeps/_workspace/src/github.com/obscuren/qml/gl/glbase/glbase.go b/Godeps/_workspace/src/github.com/obscuren/qml/gl/glbase/glbase.go deleted file mode 100644 index c483b15a2..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/gl/glbase/glbase.go +++ /dev/null @@ -1,33 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/log.go b/Godeps/_workspace/src/github.com/obscuren/qml/log.go deleted file mode 100644 index 5301e63b0..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/log.go +++ /dev/null @@ -1,157 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/qml.go b/Godeps/_workspace/src/github.com/obscuren/qml/qml.go deleted file mode 100644 index 1fa8f8ad4..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/qml.go +++ /dev/null @@ -1,1109 +0,0 @@ -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 fold *valueFold - if cerr = C.objectGoAddr(obj.addr, (*unsafe.Pointer)(unsafe.Pointer(&fold))); cerr == nil { - 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[*interface{}]bool) - -// 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() { - cerr = C.objectConnect(obj.addr, csignal, csignallen, obj.engine.addr, unsafe.Pointer(&function), C.int(funcv.Type().NumIn())) - if cerr == nil { - connectedFunction[&function] = true - stats.connectionsAlive(+1) - } - }) - cmust(cerr) -} - -//export hookSignalDisconnect -func hookSignalDisconnect(funcp unsafe.Pointer) { - before := len(connectedFunction) - delete(connectedFunction, (*interface{})(funcp)) - if before == len(connectedFunction) { - panic("disconnecting unknown signal function") - } - stats.connectionsAlive(-1) -} - -//export hookSignalCall -func hookSignalCall(enginep unsafe.Pointer, funcp unsafe.Pointer, args *C.DataValue) { - engine := engines[enginep] - if engine == nil { - panic("signal called after engine was destroyed") - } - funcv := reflect.ValueOf(*(*interface{})(funcp)) - 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 []*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) - if localSpec.Singleton { - cres = C.registerSingleton(cloc, C.int(major), C.int(minor), cname, customType, unsafe.Pointer(&localSpec)) - } else { - cres = C.registerType(cloc, C.int(major), C.int(minor), cname, customType, unsafe.Pointer(&localSpec)) - } - // 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 = append(types, &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/Godeps/_workspace/src/github.com/obscuren/qml/qml_test.go b/Godeps/_workspace/src/github.com/obscuren/qml/qml_test.go deleted file mode 100644 index 2db23cd23..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/qml_test.go +++ /dev/null @@ -1,1436 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/resources.go b/Godeps/_workspace/src/github.com/obscuren/qml/resources.go deleted file mode 100644 index 3809c1135..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/resources.go +++ /dev/null @@ -1,375 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/stats.go b/Godeps/_workspace/src/github.com/obscuren/qml/stats.go deleted file mode 100644 index 9f6e94d83..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/stats.go +++ /dev/null @@ -1,68 +0,0 @@ -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/Godeps/_workspace/src/github.com/obscuren/qml/testing.go b/Godeps/_workspace/src/github.com/obscuren/qml/testing.go deleted file mode 100644 index 39a2a691d..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/qml/testing.go +++ /dev/null @@ -1,69 +0,0 @@ -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") -} diff --git a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata.go b/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata.go deleted file mode 100644 index 6f13b810f..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata.go +++ /dev/null @@ -1,6 +0,0 @@ -// Package cdata supports the implementation of the qml package. -package cdata - -func Ref() uintptr - -func Addrs() (uintptr, uintptr) diff --git a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata12.c b/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata12.c deleted file mode 100644 index 2e60abfa2..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata12.c +++ /dev/null @@ -1,18 +0,0 @@ -// +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/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_386.s b/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_386.s deleted file mode 100644 index 7dae9b961..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_386.s +++ /dev/null @@ -1,17 +0,0 @@ -// +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/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_amd64.s b/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_amd64.s deleted file mode 100644 index 83cc22c9c..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_amd64.s +++ /dev/null @@ -1,17 +0,0 @@ -// +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/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_arm.s b/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_arm.s deleted file mode 100644 index c66bbafbf..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata14_arm.s +++ /dev/null @@ -1,18 +0,0 @@ -// +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/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata_test.go b/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata_test.go deleted file mode 100644 index e7c3f33c5..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/cdata/cdata_test.go +++ /dev/null @@ -1,42 +0,0 @@ -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/Godeps/_workspace/src/gopkg.in/qml.v1/gl/glbase/glbase.go b/Godeps/_workspace/src/gopkg.in/qml.v1/gl/glbase/glbase.go deleted file mode 100644 index c483b15a2..000000000 --- a/Godeps/_workspace/src/gopkg.in/qml.v1/gl/glbase/glbase.go +++ /dev/null @@ -1,33 +0,0 @@ -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 -)