aboutsummaryrefslogtreecommitdiff
path: root/nexgb/auto_glx.go
diff options
context:
space:
mode:
authorAndrew Gallant (Ocelot) <Andrew.Gallant@tufts.edu>2012-05-06 03:06:48 -0400
committerAndrew Gallant (Ocelot) <Andrew.Gallant@tufts.edu>2012-05-06 03:06:48 -0400
commit135cee57610cccd10009b264cce7fbcd5af367cb (patch)
treeaa4bb450d28eff241e35978233613436edafe045 /nexgb/auto_glx.go
parent70ebcf5178018a31378367f67542fc89980e62a2 (diff)
downloadhaven-135cee57610cccd10009b264cce7fbcd5af367cb.tar.gz
haven-135cee57610cccd10009b264cce7fbcd5af367cb.tar.xz
haven-135cee57610cccd10009b264cce7fbcd5af367cb.zip
auto-generated Go code ftw. ~65,000 lines. woooheee
Diffstat (limited to 'nexgb/auto_glx.go')
-rw-r--r--nexgb/auto_glx.go9356
1 files changed, 9356 insertions, 0 deletions
diff --git a/nexgb/auto_glx.go b/nexgb/auto_glx.go
new file mode 100644
index 0000000..4b6b2c5
--- /dev/null
+++ b/nexgb/auto_glx.go
@@ -0,0 +1,9356 @@
+package xgb
+
+/*
+ This file was generated by glx.xml on May 6 2012 3:00:44am EDT.
+ This file is automatically generated. Edit at your peril!
+*/
+
+// Imports are not necessary for XGB because everything is
+// in one package. They are still listed here for reference.
+// import "xproto"
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Card32'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Bool'
+
+// Skipping definition for base type 'Float'
+
+// Skipping definition for base type 'Id'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Int8'
+
+const (
+ GlxPbcetDamaged = 32791
+ GlxPbcetSaved = 32792
+)
+
+const (
+ GlxPbcdtWindow = 32793
+ GlxPbcdtPbuffer = 32794
+)
+
+const (
+ GlxGcGlCurrentBit = 1
+ GlxGcGlPointBit = 2
+ GlxGcGlLineBit = 4
+ GlxGcGlPolygonBit = 8
+ GlxGcGlPolygonStippleBit = 16
+ GlxGcGlPixelModeBit = 32
+ GlxGcGlLightingBit = 64
+ GlxGcGlFogBit = 128
+ GlxGcGlDepthBufferBit = 256
+ GlxGcGlAccumBufferBit = 512
+ GlxGcGlStencilBufferBit = 1024
+ GlxGcGlViewportBit = 2048
+ GlxGcGlTransformBit = 4096
+ GlxGcGlEnableBit = 8192
+ GlxGcGlColorBufferBit = 16384
+ GlxGcGlHintBit = 32768
+ GlxGcGlEvalBit = 65536
+ GlxGcGlListBit = 131072
+ GlxGcGlTextureBit = 262144
+ GlxGcGlScissorBit = 524288
+ GlxGcGlAllAttribBits = 16777215
+)
+
+const (
+ GlxRmGlRender = 7168
+ GlxRmGlFeedback = 7169
+ GlxRmGlSelect = 7170
+)
+
+// Skipping resource definition of 'Pixmap'
+
+// Skipping resource definition of 'Context'
+
+// Skipping resource definition of 'Pbuffer'
+
+// Skipping resource definition of 'Window'
+
+// Skipping resource definition of 'Fbconfig'
+
+// Skipping resource definition of 'Drawable'
+
+type GlxFloat32 float64
+
+type GlxFloat64 float64
+
+type GlxBool32 uint32
+
+type GlxContextTag uint32
+
+// Event definition GlxPbufferClobber (0)
+// Size: 32
+
+const GlxPbufferClobber = 0
+
+type GlxPbufferClobberEvent struct {
+ Sequence uint16
+ // padding: 1 bytes
+ EventType uint16
+ DrawType uint16
+ Drawable Id
+ BMask uint32
+ AuxBuffer uint16
+ X uint16
+ Y uint16
+ Width uint16
+ Height uint16
+ Count uint16
+ // padding: 4 bytes
+}
+
+// Event read GlxPbufferClobber
+func NewGlxPbufferClobberEvent(buf []byte) Event {
+ v := GlxPbufferClobberEvent{}
+ b := 1 // don't read event number
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.EventType = Get16(buf[b:])
+ b += 2
+
+ v.DrawType = Get16(buf[b:])
+ b += 2
+
+ v.Drawable = Id(Get32(buf[b:]))
+ b += 4
+
+ v.BMask = Get32(buf[b:])
+ b += 4
+
+ v.AuxBuffer = Get16(buf[b:])
+ b += 2
+
+ v.X = Get16(buf[b:])
+ b += 2
+
+ v.Y = Get16(buf[b:])
+ b += 2
+
+ v.Width = Get16(buf[b:])
+ b += 2
+
+ v.Height = Get16(buf[b:])
+ b += 2
+
+ v.Count = Get16(buf[b:])
+ b += 2
+
+ b += 4 // padding
+
+ return v
+}
+
+// Event write GlxPbufferClobber
+func (v GlxPbufferClobberEvent) Bytes() []byte {
+ buf := make([]byte, 32)
+ b := 0
+
+ // write event number
+ buf[b] = 0
+ b += 1
+
+ b += 1 // padding
+
+ b += 2 // skip sequence number
+
+ Put16(buf[b:], v.EventType)
+ b += 2
+
+ Put16(buf[b:], v.DrawType)
+ b += 2
+
+ Put32(buf[b:], uint32(v.Drawable))
+ b += 4
+
+ Put32(buf[b:], v.BMask)
+ b += 4
+
+ Put16(buf[b:], v.AuxBuffer)
+ b += 2
+
+ Put16(buf[b:], v.X)
+ b += 2
+
+ Put16(buf[b:], v.Y)
+ b += 2
+
+ Put16(buf[b:], v.Width)
+ b += 2
+
+ Put16(buf[b:], v.Height)
+ b += 2
+
+ Put16(buf[b:], v.Count)
+ b += 2
+
+ b += 4 // padding
+
+ return buf
+}
+
+func (v GlxPbufferClobberEvent) ImplementsEvent() {}
+
+func (v GlxPbufferClobberEvent) SequenceId() uint16 {
+ return v.Sequence
+}
+
+func (v GlxPbufferClobberEvent) String() string {
+ fieldVals := make([]string, 0, 12)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+ fieldVals = append(fieldVals, sprintf("EventType: %d", v.EventType))
+ fieldVals = append(fieldVals, sprintf("DrawType: %d", v.DrawType))
+ fieldVals = append(fieldVals, sprintf("Drawable: %d", v.Drawable))
+ fieldVals = append(fieldVals, sprintf("BMask: %d", v.BMask))
+ fieldVals = append(fieldVals, sprintf("AuxBuffer: %d", v.AuxBuffer))
+ fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+ fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+ fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+ fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+ fieldVals = append(fieldVals, sprintf("Count: %d", v.Count))
+ return "GlxPbufferClobber {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newEventFuncs[0] = NewGlxPbufferClobberEvent
+}
+
+// Error definition GlxGeneric (-1)
+// Size: 32
+
+const BadGlxGeneric = -1
+
+type GlxGenericError struct {
+ Sequence uint16
+ NiceName string
+ BadValue uint32
+ MinorOpcode uint16
+ MajorOpcode byte
+ // padding: 21 bytes
+}
+
+// Error read GlxGeneric
+func NewGlxGenericError(buf []byte) Error {
+ v := GlxGenericError{}
+ v.NiceName = "GlxGeneric"
+
+ b := 1 // skip error determinant
+ b += 1 // don't read error number
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.BadValue = Get32(buf[b:])
+ b += 4
+
+ v.MinorOpcode = Get16(buf[b:])
+ b += 2
+
+ v.MajorOpcode = buf[b]
+ b += 1
+
+ b += 21 // padding
+
+ return v
+}
+
+func (err GlxGenericError) ImplementsError() {}
+
+func (err GlxGenericError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxGenericError) BadId() Id {
+ return 0
+}
+
+func (err GlxGenericError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxGeneric {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[-1] = NewGlxGenericError
+}
+
+// ErrorCopy definition GlxBadContext (0)
+
+const BadGlxBadContext = 0
+
+type GlxBadContextError GlxGenericError
+
+func NewGlxBadContextError(buf []byte) Error {
+ v := GlxBadContextError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadContext"
+ return v
+}
+
+func (err GlxBadContextError) ImplementsError() {}
+
+func (err GlxBadContextError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadContextError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadContextError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadContext {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[0] = NewGlxBadContextError
+}
+
+// ErrorCopy definition GlxBadContextState (1)
+
+const BadGlxBadContextState = 1
+
+type GlxBadContextStateError GlxGenericError
+
+func NewGlxBadContextStateError(buf []byte) Error {
+ v := GlxBadContextStateError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadContextState"
+ return v
+}
+
+func (err GlxBadContextStateError) ImplementsError() {}
+
+func (err GlxBadContextStateError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadContextStateError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadContextStateError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadContextState {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[1] = NewGlxBadContextStateError
+}
+
+// ErrorCopy definition GlxBadDrawable (2)
+
+const BadGlxBadDrawable = 2
+
+type GlxBadDrawableError GlxGenericError
+
+func NewGlxBadDrawableError(buf []byte) Error {
+ v := GlxBadDrawableError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadDrawable"
+ return v
+}
+
+func (err GlxBadDrawableError) ImplementsError() {}
+
+func (err GlxBadDrawableError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadDrawableError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadDrawableError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadDrawable {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[2] = NewGlxBadDrawableError
+}
+
+// ErrorCopy definition GlxBadPixmap (3)
+
+const BadGlxBadPixmap = 3
+
+type GlxBadPixmapError GlxGenericError
+
+func NewGlxBadPixmapError(buf []byte) Error {
+ v := GlxBadPixmapError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadPixmap"
+ return v
+}
+
+func (err GlxBadPixmapError) ImplementsError() {}
+
+func (err GlxBadPixmapError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadPixmapError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadPixmapError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadPixmap {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[3] = NewGlxBadPixmapError
+}
+
+// ErrorCopy definition GlxBadContextTag (4)
+
+const BadGlxBadContextTag = 4
+
+type GlxBadContextTagError GlxGenericError
+
+func NewGlxBadContextTagError(buf []byte) Error {
+ v := GlxBadContextTagError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadContextTag"
+ return v
+}
+
+func (err GlxBadContextTagError) ImplementsError() {}
+
+func (err GlxBadContextTagError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadContextTagError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadContextTagError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadContextTag {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[4] = NewGlxBadContextTagError
+}
+
+// ErrorCopy definition GlxBadCurrentWindow (5)
+
+const BadGlxBadCurrentWindow = 5
+
+type GlxBadCurrentWindowError GlxGenericError
+
+func NewGlxBadCurrentWindowError(buf []byte) Error {
+ v := GlxBadCurrentWindowError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadCurrentWindow"
+ return v
+}
+
+func (err GlxBadCurrentWindowError) ImplementsError() {}
+
+func (err GlxBadCurrentWindowError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadCurrentWindowError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadCurrentWindowError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadCurrentWindow {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[5] = NewGlxBadCurrentWindowError
+}
+
+// ErrorCopy definition GlxBadRenderRequest (6)
+
+const BadGlxBadRenderRequest = 6
+
+type GlxBadRenderRequestError GlxGenericError
+
+func NewGlxBadRenderRequestError(buf []byte) Error {
+ v := GlxBadRenderRequestError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadRenderRequest"
+ return v
+}
+
+func (err GlxBadRenderRequestError) ImplementsError() {}
+
+func (err GlxBadRenderRequestError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadRenderRequestError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadRenderRequestError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadRenderRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[6] = NewGlxBadRenderRequestError
+}
+
+// ErrorCopy definition GlxBadLargeRequest (7)
+
+const BadGlxBadLargeRequest = 7
+
+type GlxBadLargeRequestError GlxGenericError
+
+func NewGlxBadLargeRequestError(buf []byte) Error {
+ v := GlxBadLargeRequestError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadLargeRequest"
+ return v
+}
+
+func (err GlxBadLargeRequestError) ImplementsError() {}
+
+func (err GlxBadLargeRequestError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadLargeRequestError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadLargeRequestError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadLargeRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[7] = NewGlxBadLargeRequestError
+}
+
+// ErrorCopy definition GlxUnsupportedPrivateRequest (8)
+
+const BadGlxUnsupportedPrivateRequest = 8
+
+type GlxUnsupportedPrivateRequestError GlxGenericError
+
+func NewGlxUnsupportedPrivateRequestError(buf []byte) Error {
+ v := GlxUnsupportedPrivateRequestError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxUnsupportedPrivateRequest"
+ return v
+}
+
+func (err GlxUnsupportedPrivateRequestError) ImplementsError() {}
+
+func (err GlxUnsupportedPrivateRequestError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxUnsupportedPrivateRequestError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxUnsupportedPrivateRequestError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxUnsupportedPrivateRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[8] = NewGlxUnsupportedPrivateRequestError
+}
+
+// ErrorCopy definition GlxBadFBConfig (9)
+
+const BadGlxBadFBConfig = 9
+
+type GlxBadFBConfigError GlxGenericError
+
+func NewGlxBadFBConfigError(buf []byte) Error {
+ v := GlxBadFBConfigError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadFBConfig"
+ return v
+}
+
+func (err GlxBadFBConfigError) ImplementsError() {}
+
+func (err GlxBadFBConfigError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadFBConfigError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadFBConfigError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadFBConfig {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[9] = NewGlxBadFBConfigError
+}
+
+// ErrorCopy definition GlxBadPbuffer (10)
+
+const BadGlxBadPbuffer = 10
+
+type GlxBadPbufferError GlxGenericError
+
+func NewGlxBadPbufferError(buf []byte) Error {
+ v := GlxBadPbufferError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadPbuffer"
+ return v
+}
+
+func (err GlxBadPbufferError) ImplementsError() {}
+
+func (err GlxBadPbufferError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadPbufferError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadPbufferError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadPbuffer {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[10] = NewGlxBadPbufferError
+}
+
+// ErrorCopy definition GlxBadCurrentDrawable (11)
+
+const BadGlxBadCurrentDrawable = 11
+
+type GlxBadCurrentDrawableError GlxGenericError
+
+func NewGlxBadCurrentDrawableError(buf []byte) Error {
+ v := GlxBadCurrentDrawableError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadCurrentDrawable"
+ return v
+}
+
+func (err GlxBadCurrentDrawableError) ImplementsError() {}
+
+func (err GlxBadCurrentDrawableError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadCurrentDrawableError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadCurrentDrawableError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadCurrentDrawable {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[11] = NewGlxBadCurrentDrawableError
+}
+
+// ErrorCopy definition GlxBadWindow (12)
+
+const BadGlxBadWindow = 12
+
+type GlxBadWindowError GlxGenericError
+
+func NewGlxBadWindowError(buf []byte) Error {
+ v := GlxBadWindowError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxBadWindow"
+ return v
+}
+
+func (err GlxBadWindowError) ImplementsError() {}
+
+func (err GlxBadWindowError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxBadWindowError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxBadWindowError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxBadWindow {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[12] = NewGlxBadWindowError
+}
+
+// ErrorCopy definition GlxGLXBadProfileARB (13)
+
+const BadGlxGLXBadProfileARB = 13
+
+type GlxGLXBadProfileARBError GlxGenericError
+
+func NewGlxGLXBadProfileARBError(buf []byte) Error {
+ v := GlxGLXBadProfileARBError(NewGlxGenericError(buf).(GlxGenericError))
+ v.NiceName = "GlxGLXBadProfileARB"
+ return v
+}
+
+func (err GlxGLXBadProfileARBError) ImplementsError() {}
+
+func (err GlxGLXBadProfileARBError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err GlxGLXBadProfileARBError) BadId() Id {
+ return Id(err.BadValue)
+}
+
+func (err GlxGLXBadProfileARBError) Error() string {
+ fieldVals := make([]string, 0, 4)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadGlxGLXBadProfileARB {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[13] = NewGlxGLXBadProfileARBError
+}
+
+// Request GlxRender
+// size: pad((8 + pad((len(Data) * 1))))
+type GlxRenderCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxRender
+func (c *Conn) GlxRender(ContextTag GlxContextTag, Data []byte) GlxRenderCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxRenderRequest(ContextTag, Data), cookie)
+ return GlxRenderCookie{cookie}
+}
+
+func (c *Conn) GlxRenderChecked(ContextTag GlxContextTag, Data []byte) GlxRenderCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxRenderRequest(ContextTag, Data), cookie)
+ return GlxRenderCookie{cookie}
+}
+
+func (cook GlxRenderCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxRender
+func (c *Conn) glxRenderRequest(ContextTag GlxContextTag, Data []byte) []byte {
+ size := pad((8 + pad((len(Data) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 1 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ copy(buf[b:], Data[:len(Data)])
+ b += pad(int(len(Data)))
+
+ return buf
+}
+
+// Request GlxRenderLarge
+// size: pad((16 + pad((int(DataLen) * 1))))
+type GlxRenderLargeCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxRenderLarge
+func (c *Conn) GlxRenderLarge(ContextTag GlxContextTag, RequestNum uint16, RequestTotal uint16, DataLen uint32, Data []byte) GlxRenderLargeCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxRenderLargeRequest(ContextTag, RequestNum, RequestTotal, DataLen, Data), cookie)
+ return GlxRenderLargeCookie{cookie}
+}
+
+func (c *Conn) GlxRenderLargeChecked(ContextTag GlxContextTag, RequestNum uint16, RequestTotal uint16, DataLen uint32, Data []byte) GlxRenderLargeCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxRenderLargeRequest(ContextTag, RequestNum, RequestTotal, DataLen, Data), cookie)
+ return GlxRenderLargeCookie{cookie}
+}
+
+func (cook GlxRenderLargeCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxRenderLarge
+func (c *Conn) glxRenderLargeRequest(ContextTag GlxContextTag, RequestNum uint16, RequestTotal uint16, DataLen uint32, Data []byte) []byte {
+ size := pad((16 + pad((int(DataLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 2 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put16(buf[b:], RequestNum)
+ b += 2
+
+ Put16(buf[b:], RequestTotal)
+ b += 2
+
+ Put32(buf[b:], DataLen)
+ b += 4
+
+ copy(buf[b:], Data[:DataLen])
+ b += pad(int(DataLen))
+
+ return buf
+}
+
+// Request GlxCreateContext
+// size: 24
+type GlxCreateContextCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreateContext
+func (c *Conn) GlxCreateContext(Context Id, Visual Visualid, Screen uint32, ShareList Id, IsDirect bool) GlxCreateContextCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreateContextRequest(Context, Visual, Screen, ShareList, IsDirect), cookie)
+ return GlxCreateContextCookie{cookie}
+}
+
+func (c *Conn) GlxCreateContextChecked(Context Id, Visual Visualid, Screen uint32, ShareList Id, IsDirect bool) GlxCreateContextCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreateContextRequest(Context, Visual, Screen, ShareList, IsDirect), cookie)
+ return GlxCreateContextCookie{cookie}
+}
+
+func (cook GlxCreateContextCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreateContext
+func (c *Conn) glxCreateContextRequest(Context Id, Visual Visualid, Screen uint32, ShareList Id, IsDirect bool) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 3 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ Put32(buf[b:], uint32(Visual))
+ b += 4
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], uint32(ShareList))
+ b += 4
+
+ if IsDirect {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ b += 3 // padding
+
+ return buf
+}
+
+// Request GlxDestroyContext
+// size: 8
+type GlxDestroyContextCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDestroyContext
+func (c *Conn) GlxDestroyContext(Context Id) GlxDestroyContextCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDestroyContextRequest(Context), cookie)
+ return GlxDestroyContextCookie{cookie}
+}
+
+func (c *Conn) GlxDestroyContextChecked(Context Id) GlxDestroyContextCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDestroyContextRequest(Context), cookie)
+ return GlxDestroyContextCookie{cookie}
+}
+
+func (cook GlxDestroyContextCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDestroyContext
+func (c *Conn) glxDestroyContextRequest(Context Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 4 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ return buf
+}
+
+// Request GlxMakeCurrent
+// size: 16
+type GlxMakeCurrentCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxMakeCurrent(Drawable Id, Context Id, OldContextTag GlxContextTag) GlxMakeCurrentCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxMakeCurrentRequest(Drawable, Context, OldContextTag), cookie)
+ return GlxMakeCurrentCookie{cookie}
+}
+
+func (c *Conn) GlxMakeCurrentUnchecked(Drawable Id, Context Id, OldContextTag GlxContextTag) GlxMakeCurrentCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxMakeCurrentRequest(Drawable, Context, OldContextTag), cookie)
+ return GlxMakeCurrentCookie{cookie}
+}
+
+// Request reply for GlxMakeCurrent
+// size: 32
+type GlxMakeCurrentReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ ContextTag GlxContextTag
+ // padding: 20 bytes
+}
+
+// Waits and reads reply data from request GlxMakeCurrent
+func (cook GlxMakeCurrentCookie) Reply() (*GlxMakeCurrentReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxMakeCurrentReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxMakeCurrent
+func glxMakeCurrentReply(buf []byte) *GlxMakeCurrentReply {
+ v := new(GlxMakeCurrentReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.ContextTag = GlxContextTag(Get32(buf[b:]))
+ b += 4
+
+ b += 20 // padding
+
+ return v
+}
+
+func (cook GlxMakeCurrentCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxMakeCurrent
+func (c *Conn) glxMakeCurrentRequest(Drawable Id, Context Id, OldContextTag GlxContextTag) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 5 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Drawable))
+ b += 4
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ Put32(buf[b:], uint32(OldContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxIsDirect
+// size: 8
+type GlxIsDirectCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxIsDirect(Context Id) GlxIsDirectCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxIsDirectRequest(Context), cookie)
+ return GlxIsDirectCookie{cookie}
+}
+
+func (c *Conn) GlxIsDirectUnchecked(Context Id) GlxIsDirectCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxIsDirectRequest(Context), cookie)
+ return GlxIsDirectCookie{cookie}
+}
+
+// Request reply for GlxIsDirect
+// size: 32
+type GlxIsDirectReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ IsDirect bool
+ // padding: 23 bytes
+}
+
+// Waits and reads reply data from request GlxIsDirect
+func (cook GlxIsDirectCookie) Reply() (*GlxIsDirectReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxIsDirectReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxIsDirect
+func glxIsDirectReply(buf []byte) *GlxIsDirectReply {
+ v := new(GlxIsDirectReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ if buf[b] == 1 {
+ v.IsDirect = true
+ } else {
+ v.IsDirect = false
+ }
+ b += 1
+
+ b += 23 // padding
+
+ return v
+}
+
+func (cook GlxIsDirectCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxIsDirect
+func (c *Conn) glxIsDirectRequest(Context Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 6 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ return buf
+}
+
+// Request GlxQueryVersion
+// size: 12
+type GlxQueryVersionCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxQueryVersion(MajorVersion uint32, MinorVersion uint32) GlxQueryVersionCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxQueryVersionRequest(MajorVersion, MinorVersion), cookie)
+ return GlxQueryVersionCookie{cookie}
+}
+
+func (c *Conn) GlxQueryVersionUnchecked(MajorVersion uint32, MinorVersion uint32) GlxQueryVersionCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxQueryVersionRequest(MajorVersion, MinorVersion), cookie)
+ return GlxQueryVersionCookie{cookie}
+}
+
+// Request reply for GlxQueryVersion
+// size: 32
+type GlxQueryVersionReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ MajorVersion uint32
+ MinorVersion uint32
+ // padding: 16 bytes
+}
+
+// Waits and reads reply data from request GlxQueryVersion
+func (cook GlxQueryVersionCookie) Reply() (*GlxQueryVersionReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxQueryVersionReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxQueryVersion
+func glxQueryVersionReply(buf []byte) *GlxQueryVersionReply {
+ v := new(GlxQueryVersionReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.MajorVersion = Get32(buf[b:])
+ b += 4
+
+ v.MinorVersion = Get32(buf[b:])
+ b += 4
+
+ b += 16 // padding
+
+ return v
+}
+
+func (cook GlxQueryVersionCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxQueryVersion
+func (c *Conn) glxQueryVersionRequest(MajorVersion uint32, MinorVersion uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 7 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], MajorVersion)
+ b += 4
+
+ Put32(buf[b:], MinorVersion)
+ b += 4
+
+ return buf
+}
+
+// Request GlxWaitGL
+// size: 8
+type GlxWaitGLCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxWaitGL
+func (c *Conn) GlxWaitGL(ContextTag GlxContextTag) GlxWaitGLCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxWaitGLRequest(ContextTag), cookie)
+ return GlxWaitGLCookie{cookie}
+}
+
+func (c *Conn) GlxWaitGLChecked(ContextTag GlxContextTag) GlxWaitGLCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxWaitGLRequest(ContextTag), cookie)
+ return GlxWaitGLCookie{cookie}
+}
+
+func (cook GlxWaitGLCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxWaitGL
+func (c *Conn) glxWaitGLRequest(ContextTag GlxContextTag) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 8 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxWaitX
+// size: 8
+type GlxWaitXCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxWaitX
+func (c *Conn) GlxWaitX(ContextTag GlxContextTag) GlxWaitXCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxWaitXRequest(ContextTag), cookie)
+ return GlxWaitXCookie{cookie}
+}
+
+func (c *Conn) GlxWaitXChecked(ContextTag GlxContextTag) GlxWaitXCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxWaitXRequest(ContextTag), cookie)
+ return GlxWaitXCookie{cookie}
+}
+
+func (cook GlxWaitXCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxWaitX
+func (c *Conn) glxWaitXRequest(ContextTag GlxContextTag) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 9 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxCopyContext
+// size: 20
+type GlxCopyContextCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCopyContext
+func (c *Conn) GlxCopyContext(Src Id, Dest Id, Mask uint32, SrcContextTag GlxContextTag) GlxCopyContextCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCopyContextRequest(Src, Dest, Mask, SrcContextTag), cookie)
+ return GlxCopyContextCookie{cookie}
+}
+
+func (c *Conn) GlxCopyContextChecked(Src Id, Dest Id, Mask uint32, SrcContextTag GlxContextTag) GlxCopyContextCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCopyContextRequest(Src, Dest, Mask, SrcContextTag), cookie)
+ return GlxCopyContextCookie{cookie}
+}
+
+func (cook GlxCopyContextCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCopyContext
+func (c *Conn) glxCopyContextRequest(Src Id, Dest Id, Mask uint32, SrcContextTag GlxContextTag) []byte {
+ size := 20
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 10 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Src))
+ b += 4
+
+ Put32(buf[b:], uint32(Dest))
+ b += 4
+
+ Put32(buf[b:], Mask)
+ b += 4
+
+ Put32(buf[b:], uint32(SrcContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxSwapBuffers
+// size: 12
+type GlxSwapBuffersCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxSwapBuffers
+func (c *Conn) GlxSwapBuffers(ContextTag GlxContextTag, Drawable Id) GlxSwapBuffersCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxSwapBuffersRequest(ContextTag, Drawable), cookie)
+ return GlxSwapBuffersCookie{cookie}
+}
+
+func (c *Conn) GlxSwapBuffersChecked(ContextTag GlxContextTag, Drawable Id) GlxSwapBuffersCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxSwapBuffersRequest(ContextTag, Drawable), cookie)
+ return GlxSwapBuffersCookie{cookie}
+}
+
+func (cook GlxSwapBuffersCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxSwapBuffers
+func (c *Conn) glxSwapBuffersRequest(ContextTag GlxContextTag, Drawable Id) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 11 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Drawable))
+ b += 4
+
+ return buf
+}
+
+// Request GlxUseXFont
+// size: 24
+type GlxUseXFontCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxUseXFont
+func (c *Conn) GlxUseXFont(ContextTag GlxContextTag, Font Id, First uint32, Count uint32, ListBase uint32) GlxUseXFontCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxUseXFontRequest(ContextTag, Font, First, Count, ListBase), cookie)
+ return GlxUseXFontCookie{cookie}
+}
+
+func (c *Conn) GlxUseXFontChecked(ContextTag GlxContextTag, Font Id, First uint32, Count uint32, ListBase uint32) GlxUseXFontCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxUseXFontRequest(ContextTag, Font, First, Count, ListBase), cookie)
+ return GlxUseXFontCookie{cookie}
+}
+
+func (cook GlxUseXFontCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxUseXFont
+func (c *Conn) glxUseXFontRequest(ContextTag GlxContextTag, Font Id, First uint32, Count uint32, ListBase uint32) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 12 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Font))
+ b += 4
+
+ Put32(buf[b:], First)
+ b += 4
+
+ Put32(buf[b:], Count)
+ b += 4
+
+ Put32(buf[b:], ListBase)
+ b += 4
+
+ return buf
+}
+
+// Request GlxCreateGLXPixmap
+// size: 20
+type GlxCreateGLXPixmapCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreateGLXPixmap
+func (c *Conn) GlxCreateGLXPixmap(Screen uint32, Visual Visualid, Pixmap Id, GlxPixmap Id) GlxCreateGLXPixmapCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreateGLXPixmapRequest(Screen, Visual, Pixmap, GlxPixmap), cookie)
+ return GlxCreateGLXPixmapCookie{cookie}
+}
+
+func (c *Conn) GlxCreateGLXPixmapChecked(Screen uint32, Visual Visualid, Pixmap Id, GlxPixmap Id) GlxCreateGLXPixmapCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreateGLXPixmapRequest(Screen, Visual, Pixmap, GlxPixmap), cookie)
+ return GlxCreateGLXPixmapCookie{cookie}
+}
+
+func (cook GlxCreateGLXPixmapCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreateGLXPixmap
+func (c *Conn) glxCreateGLXPixmapRequest(Screen uint32, Visual Visualid, Pixmap Id, GlxPixmap Id) []byte {
+ size := 20
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 13 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], uint32(Visual))
+ b += 4
+
+ Put32(buf[b:], uint32(Pixmap))
+ b += 4
+
+ Put32(buf[b:], uint32(GlxPixmap))
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetVisualConfigs
+// size: 8
+type GlxGetVisualConfigsCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetVisualConfigs(Screen uint32) GlxGetVisualConfigsCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetVisualConfigsRequest(Screen), cookie)
+ return GlxGetVisualConfigsCookie{cookie}
+}
+
+func (c *Conn) GlxGetVisualConfigsUnchecked(Screen uint32) GlxGetVisualConfigsCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetVisualConfigsRequest(Screen), cookie)
+ return GlxGetVisualConfigsCookie{cookie}
+}
+
+// Request reply for GlxGetVisualConfigs
+// size: (32 + pad((int(Length) * 4)))
+type GlxGetVisualConfigsReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ NumVisuals uint32
+ NumProperties uint32
+ // padding: 16 bytes
+ PropertyList []uint32 // size: pad((int(Length) * 4))
+}
+
+// Waits and reads reply data from request GlxGetVisualConfigs
+func (cook GlxGetVisualConfigsCookie) Reply() (*GlxGetVisualConfigsReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetVisualConfigsReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetVisualConfigs
+func glxGetVisualConfigsReply(buf []byte) *GlxGetVisualConfigsReply {
+ v := new(GlxGetVisualConfigsReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.NumVisuals = Get32(buf[b:])
+ b += 4
+
+ v.NumProperties = Get32(buf[b:])
+ b += 4
+
+ b += 16 // padding
+
+ v.PropertyList = make([]uint32, v.Length)
+ for i := 0; i < int(v.Length); i++ {
+ v.PropertyList[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetVisualConfigsCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetVisualConfigs
+func (c *Conn) glxGetVisualConfigsRequest(Screen uint32) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 14 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ return buf
+}
+
+// Request GlxDestroyGLXPixmap
+// size: 8
+type GlxDestroyGLXPixmapCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDestroyGLXPixmap
+func (c *Conn) GlxDestroyGLXPixmap(GlxPixmap Id) GlxDestroyGLXPixmapCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDestroyGLXPixmapRequest(GlxPixmap), cookie)
+ return GlxDestroyGLXPixmapCookie{cookie}
+}
+
+func (c *Conn) GlxDestroyGLXPixmapChecked(GlxPixmap Id) GlxDestroyGLXPixmapCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDestroyGLXPixmapRequest(GlxPixmap), cookie)
+ return GlxDestroyGLXPixmapCookie{cookie}
+}
+
+func (cook GlxDestroyGLXPixmapCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDestroyGLXPixmap
+func (c *Conn) glxDestroyGLXPixmapRequest(GlxPixmap Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 15 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(GlxPixmap))
+ b += 4
+
+ return buf
+}
+
+// Request GlxVendorPrivate
+// size: pad((12 + pad((len(Data) * 1))))
+type GlxVendorPrivateCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxVendorPrivate
+func (c *Conn) GlxVendorPrivate(VendorCode uint32, ContextTag GlxContextTag, Data []byte) GlxVendorPrivateCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxVendorPrivateRequest(VendorCode, ContextTag, Data), cookie)
+ return GlxVendorPrivateCookie{cookie}
+}
+
+func (c *Conn) GlxVendorPrivateChecked(VendorCode uint32, ContextTag GlxContextTag, Data []byte) GlxVendorPrivateCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxVendorPrivateRequest(VendorCode, ContextTag, Data), cookie)
+ return GlxVendorPrivateCookie{cookie}
+}
+
+func (cook GlxVendorPrivateCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxVendorPrivate
+func (c *Conn) glxVendorPrivateRequest(VendorCode uint32, ContextTag GlxContextTag, Data []byte) []byte {
+ size := pad((12 + pad((len(Data) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 16 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], VendorCode)
+ b += 4
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ copy(buf[b:], Data[:len(Data)])
+ b += pad(int(len(Data)))
+
+ return buf
+}
+
+// Request GlxVendorPrivateWithReply
+// size: pad((12 + pad((len(Data) * 1))))
+type GlxVendorPrivateWithReplyCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxVendorPrivateWithReply(VendorCode uint32, ContextTag GlxContextTag, Data []byte) GlxVendorPrivateWithReplyCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxVendorPrivateWithReplyRequest(VendorCode, ContextTag, Data), cookie)
+ return GlxVendorPrivateWithReplyCookie{cookie}
+}
+
+func (c *Conn) GlxVendorPrivateWithReplyUnchecked(VendorCode uint32, ContextTag GlxContextTag, Data []byte) GlxVendorPrivateWithReplyCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxVendorPrivateWithReplyRequest(VendorCode, ContextTag, Data), cookie)
+ return GlxVendorPrivateWithReplyCookie{cookie}
+}
+
+// Request reply for GlxVendorPrivateWithReply
+// size: (36 + pad(((int(Length) * 4) * 1)))
+type GlxVendorPrivateWithReplyReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ Retval uint32
+ Data1 []byte // size: 24
+ Data2 []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxVendorPrivateWithReply
+func (cook GlxVendorPrivateWithReplyCookie) Reply() (*GlxVendorPrivateWithReplyReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxVendorPrivateWithReplyReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxVendorPrivateWithReply
+func glxVendorPrivateWithReplyReply(buf []byte) *GlxVendorPrivateWithReplyReply {
+ v := new(GlxVendorPrivateWithReplyReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.Retval = Get32(buf[b:])
+ b += 4
+
+ v.Data1 = make([]byte, 24)
+ copy(v.Data1[:24], buf[b:])
+ b += pad(int(24))
+
+ v.Data2 = make([]byte, (int(v.Length) * 4))
+ copy(v.Data2[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxVendorPrivateWithReplyCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxVendorPrivateWithReply
+func (c *Conn) glxVendorPrivateWithReplyRequest(VendorCode uint32, ContextTag GlxContextTag, Data []byte) []byte {
+ size := pad((12 + pad((len(Data) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 17 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], VendorCode)
+ b += 4
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ copy(buf[b:], Data[:len(Data)])
+ b += pad(int(len(Data)))
+
+ return buf
+}
+
+// Request GlxQueryExtensionsString
+// size: 8
+type GlxQueryExtensionsStringCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxQueryExtensionsString(Screen uint32) GlxQueryExtensionsStringCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxQueryExtensionsStringRequest(Screen), cookie)
+ return GlxQueryExtensionsStringCookie{cookie}
+}
+
+func (c *Conn) GlxQueryExtensionsStringUnchecked(Screen uint32) GlxQueryExtensionsStringCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxQueryExtensionsStringRequest(Screen), cookie)
+ return GlxQueryExtensionsStringCookie{cookie}
+}
+
+// Request reply for GlxQueryExtensionsString
+// size: 32
+type GlxQueryExtensionsStringReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ // padding: 16 bytes
+}
+
+// Waits and reads reply data from request GlxQueryExtensionsString
+func (cook GlxQueryExtensionsStringCookie) Reply() (*GlxQueryExtensionsStringReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxQueryExtensionsStringReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxQueryExtensionsString
+func glxQueryExtensionsStringReply(buf []byte) *GlxQueryExtensionsStringReply {
+ v := new(GlxQueryExtensionsStringReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ b += 16 // padding
+
+ return v
+}
+
+func (cook GlxQueryExtensionsStringCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxQueryExtensionsString
+func (c *Conn) glxQueryExtensionsStringRequest(Screen uint32) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 18 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ return buf
+}
+
+// Request GlxQueryServerString
+// size: 12
+type GlxQueryServerStringCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxQueryServerString(Screen uint32, Name uint32) GlxQueryServerStringCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxQueryServerStringRequest(Screen, Name), cookie)
+ return GlxQueryServerStringCookie{cookie}
+}
+
+func (c *Conn) GlxQueryServerStringUnchecked(Screen uint32, Name uint32) GlxQueryServerStringCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxQueryServerStringRequest(Screen, Name), cookie)
+ return GlxQueryServerStringCookie{cookie}
+}
+
+// Request reply for GlxQueryServerString
+// size: (32 + pad((int(StrLen) * 1)))
+type GlxQueryServerStringReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ StrLen uint32
+ // padding: 16 bytes
+ String string // size: pad((int(StrLen) * 1))
+}
+
+// Waits and reads reply data from request GlxQueryServerString
+func (cook GlxQueryServerStringCookie) Reply() (*GlxQueryServerStringReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxQueryServerStringReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxQueryServerString
+func glxQueryServerStringReply(buf []byte) *GlxQueryServerStringReply {
+ v := new(GlxQueryServerStringReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.StrLen = Get32(buf[b:])
+ b += 4
+
+ b += 16 // padding
+
+ {
+ byteString := make([]byte, v.StrLen)
+ copy(byteString[:v.StrLen], buf[b:])
+ v.String = string(byteString)
+ b += pad(int(v.StrLen))
+ }
+
+ return v
+}
+
+func (cook GlxQueryServerStringCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxQueryServerString
+func (c *Conn) glxQueryServerStringRequest(Screen uint32, Name uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 19 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], Name)
+ b += 4
+
+ return buf
+}
+
+// Request GlxClientInfo
+// size: pad((16 + pad((int(StrLen) * 1))))
+type GlxClientInfoCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxClientInfo
+func (c *Conn) GlxClientInfo(MajorVersion uint32, MinorVersion uint32, StrLen uint32, String string) GlxClientInfoCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxClientInfoRequest(MajorVersion, MinorVersion, StrLen, String), cookie)
+ return GlxClientInfoCookie{cookie}
+}
+
+func (c *Conn) GlxClientInfoChecked(MajorVersion uint32, MinorVersion uint32, StrLen uint32, String string) GlxClientInfoCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxClientInfoRequest(MajorVersion, MinorVersion, StrLen, String), cookie)
+ return GlxClientInfoCookie{cookie}
+}
+
+func (cook GlxClientInfoCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxClientInfo
+func (c *Conn) glxClientInfoRequest(MajorVersion uint32, MinorVersion uint32, StrLen uint32, String string) []byte {
+ size := pad((16 + pad((int(StrLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 20 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], MajorVersion)
+ b += 4
+
+ Put32(buf[b:], MinorVersion)
+ b += 4
+
+ Put32(buf[b:], StrLen)
+ b += 4
+
+ copy(buf[b:], String[:StrLen])
+ b += pad(int(StrLen))
+
+ return buf
+}
+
+// Request GlxGetFBConfigs
+// size: 8
+type GlxGetFBConfigsCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetFBConfigs(Screen uint32) GlxGetFBConfigsCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetFBConfigsRequest(Screen), cookie)
+ return GlxGetFBConfigsCookie{cookie}
+}
+
+func (c *Conn) GlxGetFBConfigsUnchecked(Screen uint32) GlxGetFBConfigsCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetFBConfigsRequest(Screen), cookie)
+ return GlxGetFBConfigsCookie{cookie}
+}
+
+// Request reply for GlxGetFBConfigs
+// size: (32 + pad((int(Length) * 4)))
+type GlxGetFBConfigsReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ NumFbConfigs uint32
+ NumProperties uint32
+ // padding: 16 bytes
+ PropertyList []uint32 // size: pad((int(Length) * 4))
+}
+
+// Waits and reads reply data from request GlxGetFBConfigs
+func (cook GlxGetFBConfigsCookie) Reply() (*GlxGetFBConfigsReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetFBConfigsReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetFBConfigs
+func glxGetFBConfigsReply(buf []byte) *GlxGetFBConfigsReply {
+ v := new(GlxGetFBConfigsReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.NumFbConfigs = Get32(buf[b:])
+ b += 4
+
+ v.NumProperties = Get32(buf[b:])
+ b += 4
+
+ b += 16 // padding
+
+ v.PropertyList = make([]uint32, v.Length)
+ for i := 0; i < int(v.Length); i++ {
+ v.PropertyList[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetFBConfigsCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetFBConfigs
+func (c *Conn) glxGetFBConfigsRequest(Screen uint32) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 21 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ return buf
+}
+
+// Request GlxCreatePixmap
+// size: pad((24 + pad(((int(NumAttribs) * 2) * 4))))
+type GlxCreatePixmapCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreatePixmap
+func (c *Conn) GlxCreatePixmap(Screen uint32, Fbconfig Id, Pixmap Id, GlxPixmap Id, NumAttribs uint32, Attribs []uint32) GlxCreatePixmapCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreatePixmapRequest(Screen, Fbconfig, Pixmap, GlxPixmap, NumAttribs, Attribs), cookie)
+ return GlxCreatePixmapCookie{cookie}
+}
+
+func (c *Conn) GlxCreatePixmapChecked(Screen uint32, Fbconfig Id, Pixmap Id, GlxPixmap Id, NumAttribs uint32, Attribs []uint32) GlxCreatePixmapCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreatePixmapRequest(Screen, Fbconfig, Pixmap, GlxPixmap, NumAttribs, Attribs), cookie)
+ return GlxCreatePixmapCookie{cookie}
+}
+
+func (cook GlxCreatePixmapCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreatePixmap
+func (c *Conn) glxCreatePixmapRequest(Screen uint32, Fbconfig Id, Pixmap Id, GlxPixmap Id, NumAttribs uint32, Attribs []uint32) []byte {
+ size := pad((24 + pad(((int(NumAttribs) * 2) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 22 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], uint32(Fbconfig))
+ b += 4
+
+ Put32(buf[b:], uint32(Pixmap))
+ b += 4
+
+ Put32(buf[b:], uint32(GlxPixmap))
+ b += 4
+
+ Put32(buf[b:], NumAttribs)
+ b += 4
+
+ for i := 0; i < int((int(NumAttribs) * 2)); i++ {
+ Put32(buf[b:], Attribs[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxDestroyPixmap
+// size: 8
+type GlxDestroyPixmapCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDestroyPixmap
+func (c *Conn) GlxDestroyPixmap(GlxPixmap Id) GlxDestroyPixmapCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDestroyPixmapRequest(GlxPixmap), cookie)
+ return GlxDestroyPixmapCookie{cookie}
+}
+
+func (c *Conn) GlxDestroyPixmapChecked(GlxPixmap Id) GlxDestroyPixmapCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDestroyPixmapRequest(GlxPixmap), cookie)
+ return GlxDestroyPixmapCookie{cookie}
+}
+
+func (cook GlxDestroyPixmapCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDestroyPixmap
+func (c *Conn) glxDestroyPixmapRequest(GlxPixmap Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 23 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(GlxPixmap))
+ b += 4
+
+ return buf
+}
+
+// Request GlxCreateNewContext
+// size: 28
+type GlxCreateNewContextCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreateNewContext
+func (c *Conn) GlxCreateNewContext(Context Id, Fbconfig Id, Screen uint32, RenderType uint32, ShareList Id, IsDirect bool) GlxCreateNewContextCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreateNewContextRequest(Context, Fbconfig, Screen, RenderType, ShareList, IsDirect), cookie)
+ return GlxCreateNewContextCookie{cookie}
+}
+
+func (c *Conn) GlxCreateNewContextChecked(Context Id, Fbconfig Id, Screen uint32, RenderType uint32, ShareList Id, IsDirect bool) GlxCreateNewContextCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreateNewContextRequest(Context, Fbconfig, Screen, RenderType, ShareList, IsDirect), cookie)
+ return GlxCreateNewContextCookie{cookie}
+}
+
+func (cook GlxCreateNewContextCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreateNewContext
+func (c *Conn) glxCreateNewContextRequest(Context Id, Fbconfig Id, Screen uint32, RenderType uint32, ShareList Id, IsDirect bool) []byte {
+ size := 28
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 24 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ Put32(buf[b:], uint32(Fbconfig))
+ b += 4
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], RenderType)
+ b += 4
+
+ Put32(buf[b:], uint32(ShareList))
+ b += 4
+
+ if IsDirect {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ b += 3 // padding
+
+ return buf
+}
+
+// Request GlxQueryContext
+// size: 8
+type GlxQueryContextCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxQueryContext(Context Id) GlxQueryContextCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxQueryContextRequest(Context), cookie)
+ return GlxQueryContextCookie{cookie}
+}
+
+func (c *Conn) GlxQueryContextUnchecked(Context Id) GlxQueryContextCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxQueryContextRequest(Context), cookie)
+ return GlxQueryContextCookie{cookie}
+}
+
+// Request reply for GlxQueryContext
+// size: (32 + pad(((int(NumAttribs) * 2) * 4)))
+type GlxQueryContextReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ NumAttribs uint32
+ // padding: 20 bytes
+ Attribs []uint32 // size: pad(((int(NumAttribs) * 2) * 4))
+}
+
+// Waits and reads reply data from request GlxQueryContext
+func (cook GlxQueryContextCookie) Reply() (*GlxQueryContextReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxQueryContextReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxQueryContext
+func glxQueryContextReply(buf []byte) *GlxQueryContextReply {
+ v := new(GlxQueryContextReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.NumAttribs = Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ v.Attribs = make([]uint32, (int(v.NumAttribs) * 2))
+ for i := 0; i < int((int(v.NumAttribs) * 2)); i++ {
+ v.Attribs[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxQueryContextCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxQueryContext
+func (c *Conn) glxQueryContextRequest(Context Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 25 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ return buf
+}
+
+// Request GlxMakeContextCurrent
+// size: 20
+type GlxMakeContextCurrentCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxMakeContextCurrent(OldContextTag GlxContextTag, Drawable Id, ReadDrawable Id, Context Id) GlxMakeContextCurrentCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxMakeContextCurrentRequest(OldContextTag, Drawable, ReadDrawable, Context), cookie)
+ return GlxMakeContextCurrentCookie{cookie}
+}
+
+func (c *Conn) GlxMakeContextCurrentUnchecked(OldContextTag GlxContextTag, Drawable Id, ReadDrawable Id, Context Id) GlxMakeContextCurrentCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxMakeContextCurrentRequest(OldContextTag, Drawable, ReadDrawable, Context), cookie)
+ return GlxMakeContextCurrentCookie{cookie}
+}
+
+// Request reply for GlxMakeContextCurrent
+// size: 32
+type GlxMakeContextCurrentReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ ContextTag GlxContextTag
+ // padding: 20 bytes
+}
+
+// Waits and reads reply data from request GlxMakeContextCurrent
+func (cook GlxMakeContextCurrentCookie) Reply() (*GlxMakeContextCurrentReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxMakeContextCurrentReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxMakeContextCurrent
+func glxMakeContextCurrentReply(buf []byte) *GlxMakeContextCurrentReply {
+ v := new(GlxMakeContextCurrentReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.ContextTag = GlxContextTag(Get32(buf[b:]))
+ b += 4
+
+ b += 20 // padding
+
+ return v
+}
+
+func (cook GlxMakeContextCurrentCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxMakeContextCurrent
+func (c *Conn) glxMakeContextCurrentRequest(OldContextTag GlxContextTag, Drawable Id, ReadDrawable Id, Context Id) []byte {
+ size := 20
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 26 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(OldContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Drawable))
+ b += 4
+
+ Put32(buf[b:], uint32(ReadDrawable))
+ b += 4
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ return buf
+}
+
+// Request GlxCreatePbuffer
+// size: pad((20 + pad(((int(NumAttribs) * 2) * 4))))
+type GlxCreatePbufferCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreatePbuffer
+func (c *Conn) GlxCreatePbuffer(Screen uint32, Fbconfig Id, Pbuffer Id, NumAttribs uint32, Attribs []uint32) GlxCreatePbufferCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreatePbufferRequest(Screen, Fbconfig, Pbuffer, NumAttribs, Attribs), cookie)
+ return GlxCreatePbufferCookie{cookie}
+}
+
+func (c *Conn) GlxCreatePbufferChecked(Screen uint32, Fbconfig Id, Pbuffer Id, NumAttribs uint32, Attribs []uint32) GlxCreatePbufferCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreatePbufferRequest(Screen, Fbconfig, Pbuffer, NumAttribs, Attribs), cookie)
+ return GlxCreatePbufferCookie{cookie}
+}
+
+func (cook GlxCreatePbufferCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreatePbuffer
+func (c *Conn) glxCreatePbufferRequest(Screen uint32, Fbconfig Id, Pbuffer Id, NumAttribs uint32, Attribs []uint32) []byte {
+ size := pad((20 + pad(((int(NumAttribs) * 2) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 27 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], uint32(Fbconfig))
+ b += 4
+
+ Put32(buf[b:], uint32(Pbuffer))
+ b += 4
+
+ Put32(buf[b:], NumAttribs)
+ b += 4
+
+ for i := 0; i < int((int(NumAttribs) * 2)); i++ {
+ Put32(buf[b:], Attribs[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxDestroyPbuffer
+// size: 8
+type GlxDestroyPbufferCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDestroyPbuffer
+func (c *Conn) GlxDestroyPbuffer(Pbuffer Id) GlxDestroyPbufferCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDestroyPbufferRequest(Pbuffer), cookie)
+ return GlxDestroyPbufferCookie{cookie}
+}
+
+func (c *Conn) GlxDestroyPbufferChecked(Pbuffer Id) GlxDestroyPbufferCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDestroyPbufferRequest(Pbuffer), cookie)
+ return GlxDestroyPbufferCookie{cookie}
+}
+
+func (cook GlxDestroyPbufferCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDestroyPbuffer
+func (c *Conn) glxDestroyPbufferRequest(Pbuffer Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 28 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Pbuffer))
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetDrawableAttributes
+// size: 8
+type GlxGetDrawableAttributesCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetDrawableAttributes(Drawable Id) GlxGetDrawableAttributesCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetDrawableAttributesRequest(Drawable), cookie)
+ return GlxGetDrawableAttributesCookie{cookie}
+}
+
+func (c *Conn) GlxGetDrawableAttributesUnchecked(Drawable Id) GlxGetDrawableAttributesCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetDrawableAttributesRequest(Drawable), cookie)
+ return GlxGetDrawableAttributesCookie{cookie}
+}
+
+// Request reply for GlxGetDrawableAttributes
+// size: (32 + pad(((int(NumAttribs) * 2) * 4)))
+type GlxGetDrawableAttributesReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ NumAttribs uint32
+ // padding: 20 bytes
+ Attribs []uint32 // size: pad(((int(NumAttribs) * 2) * 4))
+}
+
+// Waits and reads reply data from request GlxGetDrawableAttributes
+func (cook GlxGetDrawableAttributesCookie) Reply() (*GlxGetDrawableAttributesReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetDrawableAttributesReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetDrawableAttributes
+func glxGetDrawableAttributesReply(buf []byte) *GlxGetDrawableAttributesReply {
+ v := new(GlxGetDrawableAttributesReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.NumAttribs = Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ v.Attribs = make([]uint32, (int(v.NumAttribs) * 2))
+ for i := 0; i < int((int(v.NumAttribs) * 2)); i++ {
+ v.Attribs[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetDrawableAttributesCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetDrawableAttributes
+func (c *Conn) glxGetDrawableAttributesRequest(Drawable Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 29 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Drawable))
+ b += 4
+
+ return buf
+}
+
+// Request GlxChangeDrawableAttributes
+// size: pad((12 + pad(((int(NumAttribs) * 2) * 4))))
+type GlxChangeDrawableAttributesCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxChangeDrawableAttributes
+func (c *Conn) GlxChangeDrawableAttributes(Drawable Id, NumAttribs uint32, Attribs []uint32) GlxChangeDrawableAttributesCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxChangeDrawableAttributesRequest(Drawable, NumAttribs, Attribs), cookie)
+ return GlxChangeDrawableAttributesCookie{cookie}
+}
+
+func (c *Conn) GlxChangeDrawableAttributesChecked(Drawable Id, NumAttribs uint32, Attribs []uint32) GlxChangeDrawableAttributesCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxChangeDrawableAttributesRequest(Drawable, NumAttribs, Attribs), cookie)
+ return GlxChangeDrawableAttributesCookie{cookie}
+}
+
+func (cook GlxChangeDrawableAttributesCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxChangeDrawableAttributes
+func (c *Conn) glxChangeDrawableAttributesRequest(Drawable Id, NumAttribs uint32, Attribs []uint32) []byte {
+ size := pad((12 + pad(((int(NumAttribs) * 2) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 30 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Drawable))
+ b += 4
+
+ Put32(buf[b:], NumAttribs)
+ b += 4
+
+ for i := 0; i < int((int(NumAttribs) * 2)); i++ {
+ Put32(buf[b:], Attribs[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxCreateWindow
+// size: pad((24 + pad(((int(NumAttribs) * 2) * 4))))
+type GlxCreateWindowCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreateWindow
+func (c *Conn) GlxCreateWindow(Screen uint32, Fbconfig Id, Window Id, GlxWindow Id, NumAttribs uint32, Attribs []uint32) GlxCreateWindowCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreateWindowRequest(Screen, Fbconfig, Window, GlxWindow, NumAttribs, Attribs), cookie)
+ return GlxCreateWindowCookie{cookie}
+}
+
+func (c *Conn) GlxCreateWindowChecked(Screen uint32, Fbconfig Id, Window Id, GlxWindow Id, NumAttribs uint32, Attribs []uint32) GlxCreateWindowCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreateWindowRequest(Screen, Fbconfig, Window, GlxWindow, NumAttribs, Attribs), cookie)
+ return GlxCreateWindowCookie{cookie}
+}
+
+func (cook GlxCreateWindowCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreateWindow
+func (c *Conn) glxCreateWindowRequest(Screen uint32, Fbconfig Id, Window Id, GlxWindow Id, NumAttribs uint32, Attribs []uint32) []byte {
+ size := pad((24 + pad(((int(NumAttribs) * 2) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 31 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], uint32(Fbconfig))
+ b += 4
+
+ Put32(buf[b:], uint32(Window))
+ b += 4
+
+ Put32(buf[b:], uint32(GlxWindow))
+ b += 4
+
+ Put32(buf[b:], NumAttribs)
+ b += 4
+
+ for i := 0; i < int((int(NumAttribs) * 2)); i++ {
+ Put32(buf[b:], Attribs[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxDeleteWindow
+// size: 8
+type GlxDeleteWindowCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDeleteWindow
+func (c *Conn) GlxDeleteWindow(Glxwindow Id) GlxDeleteWindowCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDeleteWindowRequest(Glxwindow), cookie)
+ return GlxDeleteWindowCookie{cookie}
+}
+
+func (c *Conn) GlxDeleteWindowChecked(Glxwindow Id) GlxDeleteWindowCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDeleteWindowRequest(Glxwindow), cookie)
+ return GlxDeleteWindowCookie{cookie}
+}
+
+func (cook GlxDeleteWindowCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDeleteWindow
+func (c *Conn) glxDeleteWindowRequest(Glxwindow Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 32 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Glxwindow))
+ b += 4
+
+ return buf
+}
+
+// Request GlxSetClientInfoARB
+// size: pad((((24 + pad(((int(NumVersions) * 2) * 4))) + pad((int(GlStrLen) * 1))) + pad((int(GlxStrLen) * 1))))
+type GlxSetClientInfoARBCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxSetClientInfoARB
+func (c *Conn) GlxSetClientInfoARB(MajorVersion uint32, MinorVersion uint32, NumVersions uint32, GlStrLen uint32, GlxStrLen uint32, GlVersions []uint32, GlExtensionString string, GlxExtensionString string) GlxSetClientInfoARBCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxSetClientInfoARBRequest(MajorVersion, MinorVersion, NumVersions, GlStrLen, GlxStrLen, GlVersions, GlExtensionString, GlxExtensionString), cookie)
+ return GlxSetClientInfoARBCookie{cookie}
+}
+
+func (c *Conn) GlxSetClientInfoARBChecked(MajorVersion uint32, MinorVersion uint32, NumVersions uint32, GlStrLen uint32, GlxStrLen uint32, GlVersions []uint32, GlExtensionString string, GlxExtensionString string) GlxSetClientInfoARBCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxSetClientInfoARBRequest(MajorVersion, MinorVersion, NumVersions, GlStrLen, GlxStrLen, GlVersions, GlExtensionString, GlxExtensionString), cookie)
+ return GlxSetClientInfoARBCookie{cookie}
+}
+
+func (cook GlxSetClientInfoARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxSetClientInfoARB
+func (c *Conn) glxSetClientInfoARBRequest(MajorVersion uint32, MinorVersion uint32, NumVersions uint32, GlStrLen uint32, GlxStrLen uint32, GlVersions []uint32, GlExtensionString string, GlxExtensionString string) []byte {
+ size := pad((((24 + pad(((int(NumVersions) * 2) * 4))) + pad((int(GlStrLen) * 1))) + pad((int(GlxStrLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 33 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], MajorVersion)
+ b += 4
+
+ Put32(buf[b:], MinorVersion)
+ b += 4
+
+ Put32(buf[b:], NumVersions)
+ b += 4
+
+ Put32(buf[b:], GlStrLen)
+ b += 4
+
+ Put32(buf[b:], GlxStrLen)
+ b += 4
+
+ for i := 0; i < int((int(NumVersions) * 2)); i++ {
+ Put32(buf[b:], GlVersions[i])
+ b += 4
+ }
+ b = pad(b)
+
+ copy(buf[b:], GlExtensionString[:GlStrLen])
+ b += pad(int(GlStrLen))
+
+ copy(buf[b:], GlxExtensionString[:GlxStrLen])
+ b += pad(int(GlxStrLen))
+
+ return buf
+}
+
+// Request GlxCreateContextAttribsARB
+// size: pad((28 + pad(((int(NumAttribs) * 2) * 4))))
+type GlxCreateContextAttribsARBCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxCreateContextAttribsARB
+func (c *Conn) GlxCreateContextAttribsARB(Context Id, Fbconfig Id, Screen uint32, ShareList Id, IsDirect bool, NumAttribs uint32, Attribs []uint32) GlxCreateContextAttribsARBCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxCreateContextAttribsARBRequest(Context, Fbconfig, Screen, ShareList, IsDirect, NumAttribs, Attribs), cookie)
+ return GlxCreateContextAttribsARBCookie{cookie}
+}
+
+func (c *Conn) GlxCreateContextAttribsARBChecked(Context Id, Fbconfig Id, Screen uint32, ShareList Id, IsDirect bool, NumAttribs uint32, Attribs []uint32) GlxCreateContextAttribsARBCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxCreateContextAttribsARBRequest(Context, Fbconfig, Screen, ShareList, IsDirect, NumAttribs, Attribs), cookie)
+ return GlxCreateContextAttribsARBCookie{cookie}
+}
+
+func (cook GlxCreateContextAttribsARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxCreateContextAttribsARB
+func (c *Conn) glxCreateContextAttribsARBRequest(Context Id, Fbconfig Id, Screen uint32, ShareList Id, IsDirect bool, NumAttribs uint32, Attribs []uint32) []byte {
+ size := pad((28 + pad(((int(NumAttribs) * 2) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 34 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Context))
+ b += 4
+
+ Put32(buf[b:], uint32(Fbconfig))
+ b += 4
+
+ Put32(buf[b:], Screen)
+ b += 4
+
+ Put32(buf[b:], uint32(ShareList))
+ b += 4
+
+ if IsDirect {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ b += 3 // padding
+
+ Put32(buf[b:], NumAttribs)
+ b += 4
+
+ for i := 0; i < int((int(NumAttribs) * 2)); i++ {
+ Put32(buf[b:], Attribs[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxSetClientInfo2ARB
+// size: pad((((24 + pad(((int(NumVersions) * 3) * 4))) + pad((int(GlStrLen) * 1))) + pad((int(GlxStrLen) * 1))))
+type GlxSetClientInfo2ARBCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxSetClientInfo2ARB
+func (c *Conn) GlxSetClientInfo2ARB(MajorVersion uint32, MinorVersion uint32, NumVersions uint32, GlStrLen uint32, GlxStrLen uint32, GlVersions []uint32, GlExtensionString string, GlxExtensionString string) GlxSetClientInfo2ARBCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxSetClientInfo2ARBRequest(MajorVersion, MinorVersion, NumVersions, GlStrLen, GlxStrLen, GlVersions, GlExtensionString, GlxExtensionString), cookie)
+ return GlxSetClientInfo2ARBCookie{cookie}
+}
+
+func (c *Conn) GlxSetClientInfo2ARBChecked(MajorVersion uint32, MinorVersion uint32, NumVersions uint32, GlStrLen uint32, GlxStrLen uint32, GlVersions []uint32, GlExtensionString string, GlxExtensionString string) GlxSetClientInfo2ARBCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxSetClientInfo2ARBRequest(MajorVersion, MinorVersion, NumVersions, GlStrLen, GlxStrLen, GlVersions, GlExtensionString, GlxExtensionString), cookie)
+ return GlxSetClientInfo2ARBCookie{cookie}
+}
+
+func (cook GlxSetClientInfo2ARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxSetClientInfo2ARB
+func (c *Conn) glxSetClientInfo2ARBRequest(MajorVersion uint32, MinorVersion uint32, NumVersions uint32, GlStrLen uint32, GlxStrLen uint32, GlVersions []uint32, GlExtensionString string, GlxExtensionString string) []byte {
+ size := pad((((24 + pad(((int(NumVersions) * 3) * 4))) + pad((int(GlStrLen) * 1))) + pad((int(GlxStrLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 35 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], MajorVersion)
+ b += 4
+
+ Put32(buf[b:], MinorVersion)
+ b += 4
+
+ Put32(buf[b:], NumVersions)
+ b += 4
+
+ Put32(buf[b:], GlStrLen)
+ b += 4
+
+ Put32(buf[b:], GlxStrLen)
+ b += 4
+
+ for i := 0; i < int((int(NumVersions) * 3)); i++ {
+ Put32(buf[b:], GlVersions[i])
+ b += 4
+ }
+ b = pad(b)
+
+ copy(buf[b:], GlExtensionString[:GlStrLen])
+ b += pad(int(GlStrLen))
+
+ copy(buf[b:], GlxExtensionString[:GlxStrLen])
+ b += pad(int(GlxStrLen))
+
+ return buf
+}
+
+// Request GlxNewList
+// size: 16
+type GlxNewListCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxNewList
+func (c *Conn) GlxNewList(ContextTag GlxContextTag, List uint32, Mode uint32) GlxNewListCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxNewListRequest(ContextTag, List, Mode), cookie)
+ return GlxNewListCookie{cookie}
+}
+
+func (c *Conn) GlxNewListChecked(ContextTag GlxContextTag, List uint32, Mode uint32) GlxNewListCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxNewListRequest(ContextTag, List, Mode), cookie)
+ return GlxNewListCookie{cookie}
+}
+
+func (cook GlxNewListCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxNewList
+func (c *Conn) glxNewListRequest(ContextTag GlxContextTag, List uint32, Mode uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 101 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], List)
+ b += 4
+
+ Put32(buf[b:], Mode)
+ b += 4
+
+ return buf
+}
+
+// Request GlxEndList
+// size: 8
+type GlxEndListCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxEndList
+func (c *Conn) GlxEndList(ContextTag GlxContextTag) GlxEndListCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxEndListRequest(ContextTag), cookie)
+ return GlxEndListCookie{cookie}
+}
+
+func (c *Conn) GlxEndListChecked(ContextTag GlxContextTag) GlxEndListCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxEndListRequest(ContextTag), cookie)
+ return GlxEndListCookie{cookie}
+}
+
+func (cook GlxEndListCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxEndList
+func (c *Conn) glxEndListRequest(ContextTag GlxContextTag) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 102 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxDeleteLists
+// size: 16
+type GlxDeleteListsCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDeleteLists
+func (c *Conn) GlxDeleteLists(ContextTag GlxContextTag, List uint32, Range int32) GlxDeleteListsCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDeleteListsRequest(ContextTag, List, Range), cookie)
+ return GlxDeleteListsCookie{cookie}
+}
+
+func (c *Conn) GlxDeleteListsChecked(ContextTag GlxContextTag, List uint32, Range int32) GlxDeleteListsCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDeleteListsRequest(ContextTag, List, Range), cookie)
+ return GlxDeleteListsCookie{cookie}
+}
+
+func (cook GlxDeleteListsCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDeleteLists
+func (c *Conn) glxDeleteListsRequest(ContextTag GlxContextTag, List uint32, Range int32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 103 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], List)
+ b += 4
+
+ Put32(buf[b:], uint32(Range))
+ b += 4
+
+ return buf
+}
+
+// Request GlxGenLists
+// size: 12
+type GlxGenListsCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGenLists(ContextTag GlxContextTag, Range int32) GlxGenListsCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGenListsRequest(ContextTag, Range), cookie)
+ return GlxGenListsCookie{cookie}
+}
+
+func (c *Conn) GlxGenListsUnchecked(ContextTag GlxContextTag, Range int32) GlxGenListsCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGenListsRequest(ContextTag, Range), cookie)
+ return GlxGenListsCookie{cookie}
+}
+
+// Request reply for GlxGenLists
+// size: 12
+type GlxGenListsReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ RetVal uint32
+}
+
+// Waits and reads reply data from request GlxGenLists
+func (cook GlxGenListsCookie) Reply() (*GlxGenListsReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGenListsReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGenLists
+func glxGenListsReply(buf []byte) *GlxGenListsReply {
+ v := new(GlxGenListsReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.RetVal = Get32(buf[b:])
+ b += 4
+
+ return v
+}
+
+func (cook GlxGenListsCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGenLists
+func (c *Conn) glxGenListsRequest(ContextTag GlxContextTag, Range int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 104 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Range))
+ b += 4
+
+ return buf
+}
+
+// Request GlxFeedbackBuffer
+// size: 16
+type GlxFeedbackBufferCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxFeedbackBuffer
+func (c *Conn) GlxFeedbackBuffer(ContextTag GlxContextTag, Size int32, Type int32) GlxFeedbackBufferCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxFeedbackBufferRequest(ContextTag, Size, Type), cookie)
+ return GlxFeedbackBufferCookie{cookie}
+}
+
+func (c *Conn) GlxFeedbackBufferChecked(ContextTag GlxContextTag, Size int32, Type int32) GlxFeedbackBufferCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxFeedbackBufferRequest(ContextTag, Size, Type), cookie)
+ return GlxFeedbackBufferCookie{cookie}
+}
+
+func (cook GlxFeedbackBufferCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxFeedbackBuffer
+func (c *Conn) glxFeedbackBufferRequest(ContextTag GlxContextTag, Size int32, Type int32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 105 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Size))
+ b += 4
+
+ Put32(buf[b:], uint32(Type))
+ b += 4
+
+ return buf
+}
+
+// Request GlxSelectBuffer
+// size: 12
+type GlxSelectBufferCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxSelectBuffer
+func (c *Conn) GlxSelectBuffer(ContextTag GlxContextTag, Size int32) GlxSelectBufferCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxSelectBufferRequest(ContextTag, Size), cookie)
+ return GlxSelectBufferCookie{cookie}
+}
+
+func (c *Conn) GlxSelectBufferChecked(ContextTag GlxContextTag, Size int32) GlxSelectBufferCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxSelectBufferRequest(ContextTag, Size), cookie)
+ return GlxSelectBufferCookie{cookie}
+}
+
+func (cook GlxSelectBufferCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxSelectBuffer
+func (c *Conn) glxSelectBufferRequest(ContextTag GlxContextTag, Size int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 106 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Size))
+ b += 4
+
+ return buf
+}
+
+// Request GlxRenderMode
+// size: 12
+type GlxRenderModeCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxRenderMode(ContextTag GlxContextTag, Mode uint32) GlxRenderModeCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxRenderModeRequest(ContextTag, Mode), cookie)
+ return GlxRenderModeCookie{cookie}
+}
+
+func (c *Conn) GlxRenderModeUnchecked(ContextTag GlxContextTag, Mode uint32) GlxRenderModeCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxRenderModeRequest(ContextTag, Mode), cookie)
+ return GlxRenderModeCookie{cookie}
+}
+
+// Request reply for GlxRenderMode
+// size: (32 + pad((int(N) * 4)))
+type GlxRenderModeReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ RetVal uint32
+ N uint32
+ NewMode uint32
+ // padding: 12 bytes
+ Data []uint32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxRenderMode
+func (cook GlxRenderModeCookie) Reply() (*GlxRenderModeReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxRenderModeReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxRenderMode
+func glxRenderModeReply(buf []byte) *GlxRenderModeReply {
+ v := new(GlxRenderModeReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.RetVal = Get32(buf[b:])
+ b += 4
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.NewMode = Get32(buf[b:])
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]uint32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxRenderModeCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxRenderMode
+func (c *Conn) glxRenderModeRequest(ContextTag GlxContextTag, Mode uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 107 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Mode)
+ b += 4
+
+ return buf
+}
+
+// Request GlxFinish
+// size: 8
+type GlxFinishCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxFinish(ContextTag GlxContextTag) GlxFinishCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxFinishRequest(ContextTag), cookie)
+ return GlxFinishCookie{cookie}
+}
+
+func (c *Conn) GlxFinishUnchecked(ContextTag GlxContextTag) GlxFinishCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxFinishRequest(ContextTag), cookie)
+ return GlxFinishCookie{cookie}
+}
+
+// Request reply for GlxFinish
+// size: 8
+type GlxFinishReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+}
+
+// Waits and reads reply data from request GlxFinish
+func (cook GlxFinishCookie) Reply() (*GlxFinishReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxFinishReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxFinish
+func glxFinishReply(buf []byte) *GlxFinishReply {
+ v := new(GlxFinishReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ return v
+}
+
+func (cook GlxFinishCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxFinish
+func (c *Conn) glxFinishRequest(ContextTag GlxContextTag) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 108 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxPixelStoref
+// size: 16
+type GlxPixelStorefCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxPixelStoref
+func (c *Conn) GlxPixelStoref(ContextTag GlxContextTag, Pname uint32, Datum GlxFloat32) GlxPixelStorefCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxPixelStorefRequest(ContextTag, Pname, Datum), cookie)
+ return GlxPixelStorefCookie{cookie}
+}
+
+func (c *Conn) GlxPixelStorefChecked(ContextTag GlxContextTag, Pname uint32, Datum GlxFloat32) GlxPixelStorefCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxPixelStorefRequest(ContextTag, Pname, Datum), cookie)
+ return GlxPixelStorefCookie{cookie}
+}
+
+func (cook GlxPixelStorefCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxPixelStoref
+func (c *Conn) glxPixelStorefRequest(ContextTag GlxContextTag, Pname uint32, Datum GlxFloat32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 109 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ Put32(buf[b:], uint32(Datum))
+ b += 4
+
+ return buf
+}
+
+// Request GlxPixelStorei
+// size: 16
+type GlxPixelStoreiCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxPixelStorei
+func (c *Conn) GlxPixelStorei(ContextTag GlxContextTag, Pname uint32, Datum int32) GlxPixelStoreiCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxPixelStoreiRequest(ContextTag, Pname, Datum), cookie)
+ return GlxPixelStoreiCookie{cookie}
+}
+
+func (c *Conn) GlxPixelStoreiChecked(ContextTag GlxContextTag, Pname uint32, Datum int32) GlxPixelStoreiCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxPixelStoreiRequest(ContextTag, Pname, Datum), cookie)
+ return GlxPixelStoreiCookie{cookie}
+}
+
+func (cook GlxPixelStoreiCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxPixelStorei
+func (c *Conn) glxPixelStoreiRequest(ContextTag GlxContextTag, Pname uint32, Datum int32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 110 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ Put32(buf[b:], uint32(Datum))
+ b += 4
+
+ return buf
+}
+
+// Request GlxReadPixels
+// size: 36
+type GlxReadPixelsCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxReadPixels(ContextTag GlxContextTag, X int32, Y int32, Width int32, Height int32, Format uint32, Type uint32, SwapBytes bool, LsbFirst bool) GlxReadPixelsCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxReadPixelsRequest(ContextTag, X, Y, Width, Height, Format, Type, SwapBytes, LsbFirst), cookie)
+ return GlxReadPixelsCookie{cookie}
+}
+
+func (c *Conn) GlxReadPixelsUnchecked(ContextTag GlxContextTag, X int32, Y int32, Width int32, Height int32, Format uint32, Type uint32, SwapBytes bool, LsbFirst bool) GlxReadPixelsCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxReadPixelsRequest(ContextTag, X, Y, Width, Height, Format, Type, SwapBytes, LsbFirst), cookie)
+ return GlxReadPixelsCookie{cookie}
+}
+
+// Request reply for GlxReadPixels
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxReadPixelsReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 24 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxReadPixels
+func (cook GlxReadPixelsCookie) Reply() (*GlxReadPixelsReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxReadPixelsReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxReadPixels
+func glxReadPixelsReply(buf []byte) *GlxReadPixelsReply {
+ v := new(GlxReadPixelsReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 24 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxReadPixelsCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxReadPixels
+func (c *Conn) glxReadPixelsRequest(ContextTag GlxContextTag, X int32, Y int32, Width int32, Height int32, Format uint32, Type uint32, SwapBytes bool, LsbFirst bool) []byte {
+ size := 36
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 111 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(X))
+ b += 4
+
+ Put32(buf[b:], uint32(Y))
+ b += 4
+
+ Put32(buf[b:], uint32(Width))
+ b += 4
+
+ Put32(buf[b:], uint32(Height))
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ if LsbFirst {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetBooleanv
+// size: 12
+type GlxGetBooleanvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetBooleanv(ContextTag GlxContextTag, Pname int32) GlxGetBooleanvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetBooleanvRequest(ContextTag, Pname), cookie)
+ return GlxGetBooleanvCookie{cookie}
+}
+
+func (c *Conn) GlxGetBooleanvUnchecked(ContextTag GlxContextTag, Pname int32) GlxGetBooleanvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetBooleanvRequest(ContextTag, Pname), cookie)
+ return GlxGetBooleanvCookie{cookie}
+}
+
+// Request reply for GlxGetBooleanv
+// size: (32 + pad((int(N) * 1)))
+type GlxGetBooleanvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum bool
+ // padding: 15 bytes
+ Data []bool // size: pad((int(N) * 1))
+}
+
+// Waits and reads reply data from request GlxGetBooleanv
+func (cook GlxGetBooleanvCookie) Reply() (*GlxGetBooleanvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetBooleanvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetBooleanv
+func glxGetBooleanvReply(buf []byte) *GlxGetBooleanvReply {
+ v := new(GlxGetBooleanvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ if buf[b] == 1 {
+ v.Datum = true
+ } else {
+ v.Datum = false
+ }
+ b += 1
+
+ b += 15 // padding
+
+ v.Data = make([]bool, v.N)
+ for i := 0; i < int(v.N); i++ {
+ if buf[b] == 1 {
+ v.Data[i] = true
+ } else {
+ v.Data[i] = false
+ }
+ b += 1
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetBooleanvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetBooleanv
+func (c *Conn) glxGetBooleanvRequest(ContextTag GlxContextTag, Pname int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 112 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Pname))
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetClipPlane
+// size: 12
+type GlxGetClipPlaneCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetClipPlane(ContextTag GlxContextTag, Plane int32) GlxGetClipPlaneCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetClipPlaneRequest(ContextTag, Plane), cookie)
+ return GlxGetClipPlaneCookie{cookie}
+}
+
+func (c *Conn) GlxGetClipPlaneUnchecked(ContextTag GlxContextTag, Plane int32) GlxGetClipPlaneCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetClipPlaneRequest(ContextTag, Plane), cookie)
+ return GlxGetClipPlaneCookie{cookie}
+}
+
+// Request reply for GlxGetClipPlane
+// size: (32 + pad(((int(Length) / 2) * 8)))
+type GlxGetClipPlaneReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 24 bytes
+ Data []GlxFloat64 // size: pad(((int(Length) / 2) * 8))
+}
+
+// Waits and reads reply data from request GlxGetClipPlane
+func (cook GlxGetClipPlaneCookie) Reply() (*GlxGetClipPlaneReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetClipPlaneReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetClipPlane
+func glxGetClipPlaneReply(buf []byte) *GlxGetClipPlaneReply {
+ v := new(GlxGetClipPlaneReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 24 // padding
+
+ v.Data = make([]GlxFloat64, (int(v.Length) / 2))
+ for i := 0; i < int((int(v.Length) / 2)); i++ {
+ v.Data[i] = GlxFloat64(Get64(buf[b:]))
+ b += 8
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetClipPlaneCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetClipPlane
+func (c *Conn) glxGetClipPlaneRequest(ContextTag GlxContextTag, Plane int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 113 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(Plane))
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetDoublev
+// size: 12
+type GlxGetDoublevCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetDoublev(ContextTag GlxContextTag, Pname uint32) GlxGetDoublevCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetDoublevRequest(ContextTag, Pname), cookie)
+ return GlxGetDoublevCookie{cookie}
+}
+
+func (c *Conn) GlxGetDoublevUnchecked(ContextTag GlxContextTag, Pname uint32) GlxGetDoublevCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetDoublevRequest(ContextTag, Pname), cookie)
+ return GlxGetDoublevCookie{cookie}
+}
+
+// Request reply for GlxGetDoublev
+// size: (32 + pad((int(N) * 8)))
+type GlxGetDoublevReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat64
+ // padding: 8 bytes
+ Data []GlxFloat64 // size: pad((int(N) * 8))
+}
+
+// Waits and reads reply data from request GlxGetDoublev
+func (cook GlxGetDoublevCookie) Reply() (*GlxGetDoublevReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetDoublevReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetDoublev
+func glxGetDoublevReply(buf []byte) *GlxGetDoublevReply {
+ v := new(GlxGetDoublevReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat64(Get64(buf[b:]))
+ b += 8
+
+ b += 8 // padding
+
+ v.Data = make([]GlxFloat64, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat64(Get64(buf[b:]))
+ b += 8
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetDoublevCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetDoublev
+func (c *Conn) glxGetDoublevRequest(ContextTag GlxContextTag, Pname uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 114 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetError
+// size: 8
+type GlxGetErrorCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetError(ContextTag GlxContextTag) GlxGetErrorCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetErrorRequest(ContextTag), cookie)
+ return GlxGetErrorCookie{cookie}
+}
+
+func (c *Conn) GlxGetErrorUnchecked(ContextTag GlxContextTag) GlxGetErrorCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetErrorRequest(ContextTag), cookie)
+ return GlxGetErrorCookie{cookie}
+}
+
+// Request reply for GlxGetError
+// size: 12
+type GlxGetErrorReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ Error int32
+}
+
+// Waits and reads reply data from request GlxGetError
+func (cook GlxGetErrorCookie) Reply() (*GlxGetErrorReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetErrorReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetError
+func glxGetErrorReply(buf []byte) *GlxGetErrorReply {
+ v := new(GlxGetErrorReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.Error = int32(Get32(buf[b:]))
+ b += 4
+
+ return v
+}
+
+func (cook GlxGetErrorCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetError
+func (c *Conn) glxGetErrorRequest(ContextTag GlxContextTag) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 115 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetFloatv
+// size: 12
+type GlxGetFloatvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetFloatv(ContextTag GlxContextTag, Pname uint32) GlxGetFloatvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetFloatvRequest(ContextTag, Pname), cookie)
+ return GlxGetFloatvCookie{cookie}
+}
+
+func (c *Conn) GlxGetFloatvUnchecked(ContextTag GlxContextTag, Pname uint32) GlxGetFloatvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetFloatvRequest(ContextTag, Pname), cookie)
+ return GlxGetFloatvCookie{cookie}
+}
+
+// Request reply for GlxGetFloatv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetFloatvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetFloatv
+func (cook GlxGetFloatvCookie) Reply() (*GlxGetFloatvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetFloatvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetFloatv
+func glxGetFloatvReply(buf []byte) *GlxGetFloatvReply {
+ v := new(GlxGetFloatvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetFloatvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetFloatv
+func (c *Conn) glxGetFloatvRequest(ContextTag GlxContextTag, Pname uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 116 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetIntegerv
+// size: 12
+type GlxGetIntegervCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetIntegerv(ContextTag GlxContextTag, Pname uint32) GlxGetIntegervCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetIntegervRequest(ContextTag, Pname), cookie)
+ return GlxGetIntegervCookie{cookie}
+}
+
+func (c *Conn) GlxGetIntegervUnchecked(ContextTag GlxContextTag, Pname uint32) GlxGetIntegervCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetIntegervRequest(ContextTag, Pname), cookie)
+ return GlxGetIntegervCookie{cookie}
+}
+
+// Request reply for GlxGetIntegerv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetIntegervReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetIntegerv
+func (cook GlxGetIntegervCookie) Reply() (*GlxGetIntegervReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetIntegervReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetIntegerv
+func glxGetIntegervReply(buf []byte) *GlxGetIntegervReply {
+ v := new(GlxGetIntegervReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetIntegervCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetIntegerv
+func (c *Conn) glxGetIntegervRequest(ContextTag GlxContextTag, Pname uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 117 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetLightfv
+// size: 16
+type GlxGetLightfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetLightfv(ContextTag GlxContextTag, Light uint32, Pname uint32) GlxGetLightfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetLightfvRequest(ContextTag, Light, Pname), cookie)
+ return GlxGetLightfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetLightfvUnchecked(ContextTag GlxContextTag, Light uint32, Pname uint32) GlxGetLightfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetLightfvRequest(ContextTag, Light, Pname), cookie)
+ return GlxGetLightfvCookie{cookie}
+}
+
+// Request reply for GlxGetLightfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetLightfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetLightfv
+func (cook GlxGetLightfvCookie) Reply() (*GlxGetLightfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetLightfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetLightfv
+func glxGetLightfvReply(buf []byte) *GlxGetLightfvReply {
+ v := new(GlxGetLightfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetLightfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetLightfv
+func (c *Conn) glxGetLightfvRequest(ContextTag GlxContextTag, Light uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 118 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Light)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetLightiv
+// size: 16
+type GlxGetLightivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetLightiv(ContextTag GlxContextTag, Light uint32, Pname uint32) GlxGetLightivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetLightivRequest(ContextTag, Light, Pname), cookie)
+ return GlxGetLightivCookie{cookie}
+}
+
+func (c *Conn) GlxGetLightivUnchecked(ContextTag GlxContextTag, Light uint32, Pname uint32) GlxGetLightivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetLightivRequest(ContextTag, Light, Pname), cookie)
+ return GlxGetLightivCookie{cookie}
+}
+
+// Request reply for GlxGetLightiv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetLightivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetLightiv
+func (cook GlxGetLightivCookie) Reply() (*GlxGetLightivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetLightivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetLightiv
+func glxGetLightivReply(buf []byte) *GlxGetLightivReply {
+ v := new(GlxGetLightivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetLightivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetLightiv
+func (c *Conn) glxGetLightivRequest(ContextTag GlxContextTag, Light uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 119 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Light)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMapdv
+// size: 16
+type GlxGetMapdvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMapdv(ContextTag GlxContextTag, Target uint32, Query uint32) GlxGetMapdvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMapdvRequest(ContextTag, Target, Query), cookie)
+ return GlxGetMapdvCookie{cookie}
+}
+
+func (c *Conn) GlxGetMapdvUnchecked(ContextTag GlxContextTag, Target uint32, Query uint32) GlxGetMapdvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMapdvRequest(ContextTag, Target, Query), cookie)
+ return GlxGetMapdvCookie{cookie}
+}
+
+// Request reply for GlxGetMapdv
+// size: (32 + pad((int(N) * 8)))
+type GlxGetMapdvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat64
+ // padding: 8 bytes
+ Data []GlxFloat64 // size: pad((int(N) * 8))
+}
+
+// Waits and reads reply data from request GlxGetMapdv
+func (cook GlxGetMapdvCookie) Reply() (*GlxGetMapdvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMapdvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMapdv
+func glxGetMapdvReply(buf []byte) *GlxGetMapdvReply {
+ v := new(GlxGetMapdvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat64(Get64(buf[b:]))
+ b += 8
+
+ b += 8 // padding
+
+ v.Data = make([]GlxFloat64, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat64(Get64(buf[b:]))
+ b += 8
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMapdvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMapdv
+func (c *Conn) glxGetMapdvRequest(ContextTag GlxContextTag, Target uint32, Query uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 120 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Query)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMapfv
+// size: 16
+type GlxGetMapfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMapfv(ContextTag GlxContextTag, Target uint32, Query uint32) GlxGetMapfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMapfvRequest(ContextTag, Target, Query), cookie)
+ return GlxGetMapfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetMapfvUnchecked(ContextTag GlxContextTag, Target uint32, Query uint32) GlxGetMapfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMapfvRequest(ContextTag, Target, Query), cookie)
+ return GlxGetMapfvCookie{cookie}
+}
+
+// Request reply for GlxGetMapfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetMapfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetMapfv
+func (cook GlxGetMapfvCookie) Reply() (*GlxGetMapfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMapfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMapfv
+func glxGetMapfvReply(buf []byte) *GlxGetMapfvReply {
+ v := new(GlxGetMapfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMapfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMapfv
+func (c *Conn) glxGetMapfvRequest(ContextTag GlxContextTag, Target uint32, Query uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 121 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Query)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMapiv
+// size: 16
+type GlxGetMapivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMapiv(ContextTag GlxContextTag, Target uint32, Query uint32) GlxGetMapivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMapivRequest(ContextTag, Target, Query), cookie)
+ return GlxGetMapivCookie{cookie}
+}
+
+func (c *Conn) GlxGetMapivUnchecked(ContextTag GlxContextTag, Target uint32, Query uint32) GlxGetMapivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMapivRequest(ContextTag, Target, Query), cookie)
+ return GlxGetMapivCookie{cookie}
+}
+
+// Request reply for GlxGetMapiv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetMapivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetMapiv
+func (cook GlxGetMapivCookie) Reply() (*GlxGetMapivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMapivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMapiv
+func glxGetMapivReply(buf []byte) *GlxGetMapivReply {
+ v := new(GlxGetMapivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMapivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMapiv
+func (c *Conn) glxGetMapivRequest(ContextTag GlxContextTag, Target uint32, Query uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 122 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Query)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMaterialfv
+// size: 16
+type GlxGetMaterialfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMaterialfv(ContextTag GlxContextTag, Face uint32, Pname uint32) GlxGetMaterialfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMaterialfvRequest(ContextTag, Face, Pname), cookie)
+ return GlxGetMaterialfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetMaterialfvUnchecked(ContextTag GlxContextTag, Face uint32, Pname uint32) GlxGetMaterialfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMaterialfvRequest(ContextTag, Face, Pname), cookie)
+ return GlxGetMaterialfvCookie{cookie}
+}
+
+// Request reply for GlxGetMaterialfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetMaterialfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetMaterialfv
+func (cook GlxGetMaterialfvCookie) Reply() (*GlxGetMaterialfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMaterialfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMaterialfv
+func glxGetMaterialfvReply(buf []byte) *GlxGetMaterialfvReply {
+ v := new(GlxGetMaterialfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMaterialfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMaterialfv
+func (c *Conn) glxGetMaterialfvRequest(ContextTag GlxContextTag, Face uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 123 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Face)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMaterialiv
+// size: 16
+type GlxGetMaterialivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMaterialiv(ContextTag GlxContextTag, Face uint32, Pname uint32) GlxGetMaterialivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMaterialivRequest(ContextTag, Face, Pname), cookie)
+ return GlxGetMaterialivCookie{cookie}
+}
+
+func (c *Conn) GlxGetMaterialivUnchecked(ContextTag GlxContextTag, Face uint32, Pname uint32) GlxGetMaterialivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMaterialivRequest(ContextTag, Face, Pname), cookie)
+ return GlxGetMaterialivCookie{cookie}
+}
+
+// Request reply for GlxGetMaterialiv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetMaterialivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetMaterialiv
+func (cook GlxGetMaterialivCookie) Reply() (*GlxGetMaterialivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMaterialivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMaterialiv
+func glxGetMaterialivReply(buf []byte) *GlxGetMaterialivReply {
+ v := new(GlxGetMaterialivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMaterialivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMaterialiv
+func (c *Conn) glxGetMaterialivRequest(ContextTag GlxContextTag, Face uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 124 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Face)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetPixelMapfv
+// size: 12
+type GlxGetPixelMapfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetPixelMapfv(ContextTag GlxContextTag, Map uint32) GlxGetPixelMapfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetPixelMapfvRequest(ContextTag, Map), cookie)
+ return GlxGetPixelMapfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetPixelMapfvUnchecked(ContextTag GlxContextTag, Map uint32) GlxGetPixelMapfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetPixelMapfvRequest(ContextTag, Map), cookie)
+ return GlxGetPixelMapfvCookie{cookie}
+}
+
+// Request reply for GlxGetPixelMapfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetPixelMapfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetPixelMapfv
+func (cook GlxGetPixelMapfvCookie) Reply() (*GlxGetPixelMapfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetPixelMapfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetPixelMapfv
+func glxGetPixelMapfvReply(buf []byte) *GlxGetPixelMapfvReply {
+ v := new(GlxGetPixelMapfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetPixelMapfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetPixelMapfv
+func (c *Conn) glxGetPixelMapfvRequest(ContextTag GlxContextTag, Map uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 125 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Map)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetPixelMapuiv
+// size: 12
+type GlxGetPixelMapuivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetPixelMapuiv(ContextTag GlxContextTag, Map uint32) GlxGetPixelMapuivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetPixelMapuivRequest(ContextTag, Map), cookie)
+ return GlxGetPixelMapuivCookie{cookie}
+}
+
+func (c *Conn) GlxGetPixelMapuivUnchecked(ContextTag GlxContextTag, Map uint32) GlxGetPixelMapuivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetPixelMapuivRequest(ContextTag, Map), cookie)
+ return GlxGetPixelMapuivCookie{cookie}
+}
+
+// Request reply for GlxGetPixelMapuiv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetPixelMapuivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum uint32
+ // padding: 12 bytes
+ Data []uint32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetPixelMapuiv
+func (cook GlxGetPixelMapuivCookie) Reply() (*GlxGetPixelMapuivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetPixelMapuivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetPixelMapuiv
+func glxGetPixelMapuivReply(buf []byte) *GlxGetPixelMapuivReply {
+ v := new(GlxGetPixelMapuivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = Get32(buf[b:])
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]uint32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetPixelMapuivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetPixelMapuiv
+func (c *Conn) glxGetPixelMapuivRequest(ContextTag GlxContextTag, Map uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 126 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Map)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetPixelMapusv
+// size: 12
+type GlxGetPixelMapusvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetPixelMapusv(ContextTag GlxContextTag, Map uint32) GlxGetPixelMapusvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetPixelMapusvRequest(ContextTag, Map), cookie)
+ return GlxGetPixelMapusvCookie{cookie}
+}
+
+func (c *Conn) GlxGetPixelMapusvUnchecked(ContextTag GlxContextTag, Map uint32) GlxGetPixelMapusvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetPixelMapusvRequest(ContextTag, Map), cookie)
+ return GlxGetPixelMapusvCookie{cookie}
+}
+
+// Request reply for GlxGetPixelMapusv
+// size: (34 + pad((int(N) * 2)))
+type GlxGetPixelMapusvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum uint16
+ // padding: 16 bytes
+ Data []uint16 // size: pad((int(N) * 2))
+}
+
+// Waits and reads reply data from request GlxGetPixelMapusv
+func (cook GlxGetPixelMapusvCookie) Reply() (*GlxGetPixelMapusvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetPixelMapusvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetPixelMapusv
+func glxGetPixelMapusvReply(buf []byte) *GlxGetPixelMapusvReply {
+ v := new(GlxGetPixelMapusvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = Get16(buf[b:])
+ b += 2
+
+ b += 16 // padding
+
+ v.Data = make([]uint16, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = Get16(buf[b:])
+ b += 2
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetPixelMapusvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetPixelMapusv
+func (c *Conn) glxGetPixelMapusvRequest(ContextTag GlxContextTag, Map uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 127 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Map)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetPolygonStipple
+// size: 12
+type GlxGetPolygonStippleCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetPolygonStipple(ContextTag GlxContextTag, LsbFirst bool) GlxGetPolygonStippleCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetPolygonStippleRequest(ContextTag, LsbFirst), cookie)
+ return GlxGetPolygonStippleCookie{cookie}
+}
+
+func (c *Conn) GlxGetPolygonStippleUnchecked(ContextTag GlxContextTag, LsbFirst bool) GlxGetPolygonStippleCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetPolygonStippleRequest(ContextTag, LsbFirst), cookie)
+ return GlxGetPolygonStippleCookie{cookie}
+}
+
+// Request reply for GlxGetPolygonStipple
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetPolygonStippleReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 24 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetPolygonStipple
+func (cook GlxGetPolygonStippleCookie) Reply() (*GlxGetPolygonStippleReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetPolygonStippleReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetPolygonStipple
+func glxGetPolygonStippleReply(buf []byte) *GlxGetPolygonStippleReply {
+ v := new(GlxGetPolygonStippleReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 24 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetPolygonStippleCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetPolygonStipple
+func (c *Conn) glxGetPolygonStippleRequest(ContextTag GlxContextTag, LsbFirst bool) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 128 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ if LsbFirst {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetString
+// size: 12
+type GlxGetStringCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetString(ContextTag GlxContextTag, Name uint32) GlxGetStringCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetStringRequest(ContextTag, Name), cookie)
+ return GlxGetStringCookie{cookie}
+}
+
+func (c *Conn) GlxGetStringUnchecked(ContextTag GlxContextTag, Name uint32) GlxGetStringCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetStringRequest(ContextTag, Name), cookie)
+ return GlxGetStringCookie{cookie}
+}
+
+// Request reply for GlxGetString
+// size: (32 + pad((int(N) * 1)))
+type GlxGetStringReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ // padding: 16 bytes
+ String string // size: pad((int(N) * 1))
+}
+
+// Waits and reads reply data from request GlxGetString
+func (cook GlxGetStringCookie) Reply() (*GlxGetStringReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetStringReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetString
+func glxGetStringReply(buf []byte) *GlxGetStringReply {
+ v := new(GlxGetStringReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ b += 16 // padding
+
+ {
+ byteString := make([]byte, v.N)
+ copy(byteString[:v.N], buf[b:])
+ v.String = string(byteString)
+ b += pad(int(v.N))
+ }
+
+ return v
+}
+
+func (cook GlxGetStringCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetString
+func (c *Conn) glxGetStringRequest(ContextTag GlxContextTag, Name uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 129 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Name)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexEnvfv
+// size: 16
+type GlxGetTexEnvfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexEnvfv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexEnvfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexEnvfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexEnvfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexEnvfvUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexEnvfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexEnvfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexEnvfvCookie{cookie}
+}
+
+// Request reply for GlxGetTexEnvfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexEnvfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexEnvfv
+func (cook GlxGetTexEnvfvCookie) Reply() (*GlxGetTexEnvfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexEnvfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexEnvfv
+func glxGetTexEnvfvReply(buf []byte) *GlxGetTexEnvfvReply {
+ v := new(GlxGetTexEnvfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexEnvfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexEnvfv
+func (c *Conn) glxGetTexEnvfvRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 130 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexEnviv
+// size: 16
+type GlxGetTexEnvivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexEnviv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexEnvivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexEnvivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexEnvivCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexEnvivUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexEnvivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexEnvivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexEnvivCookie{cookie}
+}
+
+// Request reply for GlxGetTexEnviv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexEnvivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexEnviv
+func (cook GlxGetTexEnvivCookie) Reply() (*GlxGetTexEnvivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexEnvivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexEnviv
+func glxGetTexEnvivReply(buf []byte) *GlxGetTexEnvivReply {
+ v := new(GlxGetTexEnvivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexEnvivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexEnviv
+func (c *Conn) glxGetTexEnvivRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 131 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexGendv
+// size: 16
+type GlxGetTexGendvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexGendv(ContextTag GlxContextTag, Coord uint32, Pname uint32) GlxGetTexGendvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexGendvRequest(ContextTag, Coord, Pname), cookie)
+ return GlxGetTexGendvCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexGendvUnchecked(ContextTag GlxContextTag, Coord uint32, Pname uint32) GlxGetTexGendvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexGendvRequest(ContextTag, Coord, Pname), cookie)
+ return GlxGetTexGendvCookie{cookie}
+}
+
+// Request reply for GlxGetTexGendv
+// size: (32 + pad((int(N) * 8)))
+type GlxGetTexGendvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat64
+ // padding: 8 bytes
+ Data []GlxFloat64 // size: pad((int(N) * 8))
+}
+
+// Waits and reads reply data from request GlxGetTexGendv
+func (cook GlxGetTexGendvCookie) Reply() (*GlxGetTexGendvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexGendvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexGendv
+func glxGetTexGendvReply(buf []byte) *GlxGetTexGendvReply {
+ v := new(GlxGetTexGendvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat64(Get64(buf[b:]))
+ b += 8
+
+ b += 8 // padding
+
+ v.Data = make([]GlxFloat64, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat64(Get64(buf[b:]))
+ b += 8
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexGendvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexGendv
+func (c *Conn) glxGetTexGendvRequest(ContextTag GlxContextTag, Coord uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 132 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Coord)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexGenfv
+// size: 16
+type GlxGetTexGenfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexGenfv(ContextTag GlxContextTag, Coord uint32, Pname uint32) GlxGetTexGenfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexGenfvRequest(ContextTag, Coord, Pname), cookie)
+ return GlxGetTexGenfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexGenfvUnchecked(ContextTag GlxContextTag, Coord uint32, Pname uint32) GlxGetTexGenfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexGenfvRequest(ContextTag, Coord, Pname), cookie)
+ return GlxGetTexGenfvCookie{cookie}
+}
+
+// Request reply for GlxGetTexGenfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexGenfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexGenfv
+func (cook GlxGetTexGenfvCookie) Reply() (*GlxGetTexGenfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexGenfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexGenfv
+func glxGetTexGenfvReply(buf []byte) *GlxGetTexGenfvReply {
+ v := new(GlxGetTexGenfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexGenfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexGenfv
+func (c *Conn) glxGetTexGenfvRequest(ContextTag GlxContextTag, Coord uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 133 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Coord)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexGeniv
+// size: 16
+type GlxGetTexGenivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexGeniv(ContextTag GlxContextTag, Coord uint32, Pname uint32) GlxGetTexGenivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexGenivRequest(ContextTag, Coord, Pname), cookie)
+ return GlxGetTexGenivCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexGenivUnchecked(ContextTag GlxContextTag, Coord uint32, Pname uint32) GlxGetTexGenivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexGenivRequest(ContextTag, Coord, Pname), cookie)
+ return GlxGetTexGenivCookie{cookie}
+}
+
+// Request reply for GlxGetTexGeniv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexGenivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexGeniv
+func (cook GlxGetTexGenivCookie) Reply() (*GlxGetTexGenivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexGenivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexGeniv
+func glxGetTexGenivReply(buf []byte) *GlxGetTexGenivReply {
+ v := new(GlxGetTexGenivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexGenivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexGeniv
+func (c *Conn) glxGetTexGenivRequest(ContextTag GlxContextTag, Coord uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 134 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Coord)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexImage
+// size: 28
+type GlxGetTexImageCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexImage(ContextTag GlxContextTag, Target uint32, Level int32, Format uint32, Type uint32, SwapBytes bool) GlxGetTexImageCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexImageRequest(ContextTag, Target, Level, Format, Type, SwapBytes), cookie)
+ return GlxGetTexImageCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexImageUnchecked(ContextTag GlxContextTag, Target uint32, Level int32, Format uint32, Type uint32, SwapBytes bool) GlxGetTexImageCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexImageRequest(ContextTag, Target, Level, Format, Type, SwapBytes), cookie)
+ return GlxGetTexImageCookie{cookie}
+}
+
+// Request reply for GlxGetTexImage
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetTexImageReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 8 bytes
+ Width int32
+ Height int32
+ Depth int32
+ // padding: 4 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetTexImage
+func (cook GlxGetTexImageCookie) Reply() (*GlxGetTexImageReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexImageReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexImage
+func glxGetTexImageReply(buf []byte) *GlxGetTexImageReply {
+ v := new(GlxGetTexImageReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 8 // padding
+
+ v.Width = int32(Get32(buf[b:]))
+ b += 4
+
+ v.Height = int32(Get32(buf[b:]))
+ b += 4
+
+ v.Depth = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 4 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetTexImageCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexImage
+func (c *Conn) glxGetTexImageRequest(ContextTag GlxContextTag, Target uint32, Level int32, Format uint32, Type uint32, SwapBytes bool) []byte {
+ size := 28
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 135 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], uint32(Level))
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetTexParameterfv
+// size: 16
+type GlxGetTexParameterfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexParameterfv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexParameterfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexParameterfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexParameterfvUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexParameterfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexParameterfvCookie{cookie}
+}
+
+// Request reply for GlxGetTexParameterfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexParameterfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexParameterfv
+func (cook GlxGetTexParameterfvCookie) Reply() (*GlxGetTexParameterfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexParameterfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexParameterfv
+func glxGetTexParameterfvReply(buf []byte) *GlxGetTexParameterfvReply {
+ v := new(GlxGetTexParameterfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexParameterfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexParameterfv
+func (c *Conn) glxGetTexParameterfvRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 136 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexParameteriv
+// size: 16
+type GlxGetTexParameterivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexParameteriv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexParameterivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexParameterivCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexParameterivUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetTexParameterivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetTexParameterivCookie{cookie}
+}
+
+// Request reply for GlxGetTexParameteriv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexParameterivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexParameteriv
+func (cook GlxGetTexParameterivCookie) Reply() (*GlxGetTexParameterivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexParameterivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexParameteriv
+func glxGetTexParameterivReply(buf []byte) *GlxGetTexParameterivReply {
+ v := new(GlxGetTexParameterivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexParameterivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexParameteriv
+func (c *Conn) glxGetTexParameterivRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 137 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexLevelParameterfv
+// size: 20
+type GlxGetTexLevelParameterfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexLevelParameterfv(ContextTag GlxContextTag, Target uint32, Level int32, Pname uint32) GlxGetTexLevelParameterfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexLevelParameterfvRequest(ContextTag, Target, Level, Pname), cookie)
+ return GlxGetTexLevelParameterfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexLevelParameterfvUnchecked(ContextTag GlxContextTag, Target uint32, Level int32, Pname uint32) GlxGetTexLevelParameterfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexLevelParameterfvRequest(ContextTag, Target, Level, Pname), cookie)
+ return GlxGetTexLevelParameterfvCookie{cookie}
+}
+
+// Request reply for GlxGetTexLevelParameterfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexLevelParameterfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexLevelParameterfv
+func (cook GlxGetTexLevelParameterfvCookie) Reply() (*GlxGetTexLevelParameterfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexLevelParameterfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexLevelParameterfv
+func glxGetTexLevelParameterfvReply(buf []byte) *GlxGetTexLevelParameterfvReply {
+ v := new(GlxGetTexLevelParameterfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexLevelParameterfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexLevelParameterfv
+func (c *Conn) glxGetTexLevelParameterfvRequest(ContextTag GlxContextTag, Target uint32, Level int32, Pname uint32) []byte {
+ size := 20
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 138 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], uint32(Level))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetTexLevelParameteriv
+// size: 20
+type GlxGetTexLevelParameterivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetTexLevelParameteriv(ContextTag GlxContextTag, Target uint32, Level int32, Pname uint32) GlxGetTexLevelParameterivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetTexLevelParameterivRequest(ContextTag, Target, Level, Pname), cookie)
+ return GlxGetTexLevelParameterivCookie{cookie}
+}
+
+func (c *Conn) GlxGetTexLevelParameterivUnchecked(ContextTag GlxContextTag, Target uint32, Level int32, Pname uint32) GlxGetTexLevelParameterivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetTexLevelParameterivRequest(ContextTag, Target, Level, Pname), cookie)
+ return GlxGetTexLevelParameterivCookie{cookie}
+}
+
+// Request reply for GlxGetTexLevelParameteriv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetTexLevelParameterivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetTexLevelParameteriv
+func (cook GlxGetTexLevelParameterivCookie) Reply() (*GlxGetTexLevelParameterivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetTexLevelParameterivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetTexLevelParameteriv
+func glxGetTexLevelParameterivReply(buf []byte) *GlxGetTexLevelParameterivReply {
+ v := new(GlxGetTexLevelParameterivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetTexLevelParameterivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetTexLevelParameteriv
+func (c *Conn) glxGetTexLevelParameterivRequest(ContextTag GlxContextTag, Target uint32, Level int32, Pname uint32) []byte {
+ size := 20
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 139 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], uint32(Level))
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxIsList
+// size: 12
+type GlxIsListCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxIsList(ContextTag GlxContextTag, List uint32) GlxIsListCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxIsListRequest(ContextTag, List), cookie)
+ return GlxIsListCookie{cookie}
+}
+
+func (c *Conn) GlxIsListUnchecked(ContextTag GlxContextTag, List uint32) GlxIsListCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxIsListRequest(ContextTag, List), cookie)
+ return GlxIsListCookie{cookie}
+}
+
+// Request reply for GlxIsList
+// size: 12
+type GlxIsListReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ RetVal GlxBool32
+}
+
+// Waits and reads reply data from request GlxIsList
+func (cook GlxIsListCookie) Reply() (*GlxIsListReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxIsListReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxIsList
+func glxIsListReply(buf []byte) *GlxIsListReply {
+ v := new(GlxIsListReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.RetVal = GlxBool32(Get32(buf[b:]))
+ b += 4
+
+ return v
+}
+
+func (cook GlxIsListCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxIsList
+func (c *Conn) glxIsListRequest(ContextTag GlxContextTag, List uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 141 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], List)
+ b += 4
+
+ return buf
+}
+
+// Request GlxFlush
+// size: 8
+type GlxFlushCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxFlush
+func (c *Conn) GlxFlush(ContextTag GlxContextTag) GlxFlushCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxFlushRequest(ContextTag), cookie)
+ return GlxFlushCookie{cookie}
+}
+
+func (c *Conn) GlxFlushChecked(ContextTag GlxContextTag) GlxFlushCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxFlushRequest(ContextTag), cookie)
+ return GlxFlushCookie{cookie}
+}
+
+func (cook GlxFlushCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxFlush
+func (c *Conn) glxFlushRequest(ContextTag GlxContextTag) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 142 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ return buf
+}
+
+// Request GlxAreTexturesResident
+// size: pad((12 + pad((int(N) * 4))))
+type GlxAreTexturesResidentCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxAreTexturesResident(ContextTag GlxContextTag, N int32, Textures []uint32) GlxAreTexturesResidentCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxAreTexturesResidentRequest(ContextTag, N, Textures), cookie)
+ return GlxAreTexturesResidentCookie{cookie}
+}
+
+func (c *Conn) GlxAreTexturesResidentUnchecked(ContextTag GlxContextTag, N int32, Textures []uint32) GlxAreTexturesResidentCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxAreTexturesResidentRequest(ContextTag, N, Textures), cookie)
+ return GlxAreTexturesResidentCookie{cookie}
+}
+
+// Request reply for GlxAreTexturesResident
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxAreTexturesResidentReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ RetVal GlxBool32
+ // padding: 20 bytes
+ Data []bool // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxAreTexturesResident
+func (cook GlxAreTexturesResidentCookie) Reply() (*GlxAreTexturesResidentReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxAreTexturesResidentReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxAreTexturesResident
+func glxAreTexturesResidentReply(buf []byte) *GlxAreTexturesResidentReply {
+ v := new(GlxAreTexturesResidentReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.RetVal = GlxBool32(Get32(buf[b:]))
+ b += 4
+
+ b += 20 // padding
+
+ v.Data = make([]bool, (int(v.Length) * 4))
+ for i := 0; i < int((int(v.Length) * 4)); i++ {
+ if buf[b] == 1 {
+ v.Data[i] = true
+ } else {
+ v.Data[i] = false
+ }
+ b += 1
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxAreTexturesResidentCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxAreTexturesResident
+func (c *Conn) glxAreTexturesResidentRequest(ContextTag GlxContextTag, N int32, Textures []uint32) []byte {
+ size := pad((12 + pad((int(N) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 143 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(N))
+ b += 4
+
+ for i := 0; i < int(N); i++ {
+ Put32(buf[b:], Textures[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxDeleteTextures
+// size: pad((12 + pad((int(N) * 4))))
+type GlxDeleteTexturesCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDeleteTextures
+func (c *Conn) GlxDeleteTextures(ContextTag GlxContextTag, N int32, Textures []uint32) GlxDeleteTexturesCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDeleteTexturesRequest(ContextTag, N, Textures), cookie)
+ return GlxDeleteTexturesCookie{cookie}
+}
+
+func (c *Conn) GlxDeleteTexturesChecked(ContextTag GlxContextTag, N int32, Textures []uint32) GlxDeleteTexturesCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDeleteTexturesRequest(ContextTag, N, Textures), cookie)
+ return GlxDeleteTexturesCookie{cookie}
+}
+
+func (cook GlxDeleteTexturesCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDeleteTextures
+func (c *Conn) glxDeleteTexturesRequest(ContextTag GlxContextTag, N int32, Textures []uint32) []byte {
+ size := pad((12 + pad((int(N) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 144 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(N))
+ b += 4
+
+ for i := 0; i < int(N); i++ {
+ Put32(buf[b:], Textures[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxGenTextures
+// size: 12
+type GlxGenTexturesCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGenTextures(ContextTag GlxContextTag, N int32) GlxGenTexturesCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGenTexturesRequest(ContextTag, N), cookie)
+ return GlxGenTexturesCookie{cookie}
+}
+
+func (c *Conn) GlxGenTexturesUnchecked(ContextTag GlxContextTag, N int32) GlxGenTexturesCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGenTexturesRequest(ContextTag, N), cookie)
+ return GlxGenTexturesCookie{cookie}
+}
+
+// Request reply for GlxGenTextures
+// size: (32 + pad((int(Length) * 4)))
+type GlxGenTexturesReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 24 bytes
+ Data []uint32 // size: pad((int(Length) * 4))
+}
+
+// Waits and reads reply data from request GlxGenTextures
+func (cook GlxGenTexturesCookie) Reply() (*GlxGenTexturesReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGenTexturesReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGenTextures
+func glxGenTexturesReply(buf []byte) *GlxGenTexturesReply {
+ v := new(GlxGenTexturesReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 24 // padding
+
+ v.Data = make([]uint32, v.Length)
+ for i := 0; i < int(v.Length); i++ {
+ v.Data[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGenTexturesCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGenTextures
+func (c *Conn) glxGenTexturesRequest(ContextTag GlxContextTag, N int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 145 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(N))
+ b += 4
+
+ return buf
+}
+
+// Request GlxIsTexture
+// size: 12
+type GlxIsTextureCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxIsTexture(ContextTag GlxContextTag, Texture uint32) GlxIsTextureCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxIsTextureRequest(ContextTag, Texture), cookie)
+ return GlxIsTextureCookie{cookie}
+}
+
+func (c *Conn) GlxIsTextureUnchecked(ContextTag GlxContextTag, Texture uint32) GlxIsTextureCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxIsTextureRequest(ContextTag, Texture), cookie)
+ return GlxIsTextureCookie{cookie}
+}
+
+// Request reply for GlxIsTexture
+// size: 12
+type GlxIsTextureReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ RetVal GlxBool32
+}
+
+// Waits and reads reply data from request GlxIsTexture
+func (cook GlxIsTextureCookie) Reply() (*GlxIsTextureReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxIsTextureReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxIsTexture
+func glxIsTextureReply(buf []byte) *GlxIsTextureReply {
+ v := new(GlxIsTextureReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.RetVal = GlxBool32(Get32(buf[b:]))
+ b += 4
+
+ return v
+}
+
+func (cook GlxIsTextureCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxIsTexture
+func (c *Conn) glxIsTextureRequest(ContextTag GlxContextTag, Texture uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 146 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Texture)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetColorTable
+// size: 24
+type GlxGetColorTableCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetColorTable(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) GlxGetColorTableCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetColorTableRequest(ContextTag, Target, Format, Type, SwapBytes), cookie)
+ return GlxGetColorTableCookie{cookie}
+}
+
+func (c *Conn) GlxGetColorTableUnchecked(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) GlxGetColorTableCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetColorTableRequest(ContextTag, Target, Format, Type, SwapBytes), cookie)
+ return GlxGetColorTableCookie{cookie}
+}
+
+// Request reply for GlxGetColorTable
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetColorTableReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 8 bytes
+ Width int32
+ // padding: 12 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetColorTable
+func (cook GlxGetColorTableCookie) Reply() (*GlxGetColorTableReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetColorTableReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetColorTable
+func glxGetColorTableReply(buf []byte) *GlxGetColorTableReply {
+ v := new(GlxGetColorTableReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 8 // padding
+
+ v.Width = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetColorTableCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetColorTable
+func (c *Conn) glxGetColorTableRequest(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 147 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetColorTableParameterfv
+// size: 16
+type GlxGetColorTableParameterfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetColorTableParameterfv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetColorTableParameterfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetColorTableParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetColorTableParameterfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetColorTableParameterfvUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetColorTableParameterfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetColorTableParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetColorTableParameterfvCookie{cookie}
+}
+
+// Request reply for GlxGetColorTableParameterfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetColorTableParameterfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetColorTableParameterfv
+func (cook GlxGetColorTableParameterfvCookie) Reply() (*GlxGetColorTableParameterfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetColorTableParameterfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetColorTableParameterfv
+func glxGetColorTableParameterfvReply(buf []byte) *GlxGetColorTableParameterfvReply {
+ v := new(GlxGetColorTableParameterfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetColorTableParameterfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetColorTableParameterfv
+func (c *Conn) glxGetColorTableParameterfvRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 148 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetColorTableParameteriv
+// size: 16
+type GlxGetColorTableParameterivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetColorTableParameteriv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetColorTableParameterivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetColorTableParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetColorTableParameterivCookie{cookie}
+}
+
+func (c *Conn) GlxGetColorTableParameterivUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetColorTableParameterivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetColorTableParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetColorTableParameterivCookie{cookie}
+}
+
+// Request reply for GlxGetColorTableParameteriv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetColorTableParameterivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetColorTableParameteriv
+func (cook GlxGetColorTableParameterivCookie) Reply() (*GlxGetColorTableParameterivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetColorTableParameterivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetColorTableParameteriv
+func glxGetColorTableParameterivReply(buf []byte) *GlxGetColorTableParameterivReply {
+ v := new(GlxGetColorTableParameterivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetColorTableParameterivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetColorTableParameteriv
+func (c *Conn) glxGetColorTableParameterivRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 149 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetConvolutionFilter
+// size: 24
+type GlxGetConvolutionFilterCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetConvolutionFilter(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) GlxGetConvolutionFilterCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetConvolutionFilterRequest(ContextTag, Target, Format, Type, SwapBytes), cookie)
+ return GlxGetConvolutionFilterCookie{cookie}
+}
+
+func (c *Conn) GlxGetConvolutionFilterUnchecked(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) GlxGetConvolutionFilterCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetConvolutionFilterRequest(ContextTag, Target, Format, Type, SwapBytes), cookie)
+ return GlxGetConvolutionFilterCookie{cookie}
+}
+
+// Request reply for GlxGetConvolutionFilter
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetConvolutionFilterReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 8 bytes
+ Width int32
+ Height int32
+ // padding: 8 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetConvolutionFilter
+func (cook GlxGetConvolutionFilterCookie) Reply() (*GlxGetConvolutionFilterReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetConvolutionFilterReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetConvolutionFilter
+func glxGetConvolutionFilterReply(buf []byte) *GlxGetConvolutionFilterReply {
+ v := new(GlxGetConvolutionFilterReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 8 // padding
+
+ v.Width = int32(Get32(buf[b:]))
+ b += 4
+
+ v.Height = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 8 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetConvolutionFilterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetConvolutionFilter
+func (c *Conn) glxGetConvolutionFilterRequest(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 150 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetConvolutionParameterfv
+// size: 16
+type GlxGetConvolutionParameterfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetConvolutionParameterfv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetConvolutionParameterfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetConvolutionParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetConvolutionParameterfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetConvolutionParameterfvUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetConvolutionParameterfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetConvolutionParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetConvolutionParameterfvCookie{cookie}
+}
+
+// Request reply for GlxGetConvolutionParameterfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetConvolutionParameterfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetConvolutionParameterfv
+func (cook GlxGetConvolutionParameterfvCookie) Reply() (*GlxGetConvolutionParameterfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetConvolutionParameterfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetConvolutionParameterfv
+func glxGetConvolutionParameterfvReply(buf []byte) *GlxGetConvolutionParameterfvReply {
+ v := new(GlxGetConvolutionParameterfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetConvolutionParameterfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetConvolutionParameterfv
+func (c *Conn) glxGetConvolutionParameterfvRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 151 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetConvolutionParameteriv
+// size: 16
+type GlxGetConvolutionParameterivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetConvolutionParameteriv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetConvolutionParameterivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetConvolutionParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetConvolutionParameterivCookie{cookie}
+}
+
+func (c *Conn) GlxGetConvolutionParameterivUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetConvolutionParameterivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetConvolutionParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetConvolutionParameterivCookie{cookie}
+}
+
+// Request reply for GlxGetConvolutionParameteriv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetConvolutionParameterivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetConvolutionParameteriv
+func (cook GlxGetConvolutionParameterivCookie) Reply() (*GlxGetConvolutionParameterivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetConvolutionParameterivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetConvolutionParameteriv
+func glxGetConvolutionParameterivReply(buf []byte) *GlxGetConvolutionParameterivReply {
+ v := new(GlxGetConvolutionParameterivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetConvolutionParameterivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetConvolutionParameteriv
+func (c *Conn) glxGetConvolutionParameterivRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 152 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetSeparableFilter
+// size: 24
+type GlxGetSeparableFilterCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetSeparableFilter(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) GlxGetSeparableFilterCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetSeparableFilterRequest(ContextTag, Target, Format, Type, SwapBytes), cookie)
+ return GlxGetSeparableFilterCookie{cookie}
+}
+
+func (c *Conn) GlxGetSeparableFilterUnchecked(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) GlxGetSeparableFilterCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetSeparableFilterRequest(ContextTag, Target, Format, Type, SwapBytes), cookie)
+ return GlxGetSeparableFilterCookie{cookie}
+}
+
+// Request reply for GlxGetSeparableFilter
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetSeparableFilterReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 8 bytes
+ RowW int32
+ ColH int32
+ // padding: 8 bytes
+ RowsAndCols []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetSeparableFilter
+func (cook GlxGetSeparableFilterCookie) Reply() (*GlxGetSeparableFilterReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetSeparableFilterReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetSeparableFilter
+func glxGetSeparableFilterReply(buf []byte) *GlxGetSeparableFilterReply {
+ v := new(GlxGetSeparableFilterReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 8 // padding
+
+ v.RowW = int32(Get32(buf[b:]))
+ b += 4
+
+ v.ColH = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 8 // padding
+
+ v.RowsAndCols = make([]byte, (int(v.Length) * 4))
+ copy(v.RowsAndCols[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetSeparableFilterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetSeparableFilter
+func (c *Conn) glxGetSeparableFilterRequest(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 153 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetHistogram
+// size: 24
+type GlxGetHistogramCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetHistogram(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool, Reset bool) GlxGetHistogramCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetHistogramRequest(ContextTag, Target, Format, Type, SwapBytes, Reset), cookie)
+ return GlxGetHistogramCookie{cookie}
+}
+
+func (c *Conn) GlxGetHistogramUnchecked(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool, Reset bool) GlxGetHistogramCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetHistogramRequest(ContextTag, Target, Format, Type, SwapBytes, Reset), cookie)
+ return GlxGetHistogramCookie{cookie}
+}
+
+// Request reply for GlxGetHistogram
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetHistogramReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 8 bytes
+ Width int32
+ // padding: 12 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetHistogram
+func (cook GlxGetHistogramCookie) Reply() (*GlxGetHistogramReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetHistogramReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetHistogram
+func glxGetHistogramReply(buf []byte) *GlxGetHistogramReply {
+ v := new(GlxGetHistogramReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 8 // padding
+
+ v.Width = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetHistogramCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetHistogram
+func (c *Conn) glxGetHistogramRequest(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool, Reset bool) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 154 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ if Reset {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetHistogramParameterfv
+// size: 16
+type GlxGetHistogramParameterfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetHistogramParameterfv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetHistogramParameterfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetHistogramParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetHistogramParameterfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetHistogramParameterfvUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetHistogramParameterfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetHistogramParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetHistogramParameterfvCookie{cookie}
+}
+
+// Request reply for GlxGetHistogramParameterfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetHistogramParameterfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetHistogramParameterfv
+func (cook GlxGetHistogramParameterfvCookie) Reply() (*GlxGetHistogramParameterfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetHistogramParameterfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetHistogramParameterfv
+func glxGetHistogramParameterfvReply(buf []byte) *GlxGetHistogramParameterfvReply {
+ v := new(GlxGetHistogramParameterfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetHistogramParameterfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetHistogramParameterfv
+func (c *Conn) glxGetHistogramParameterfvRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 155 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetHistogramParameteriv
+// size: 16
+type GlxGetHistogramParameterivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetHistogramParameteriv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetHistogramParameterivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetHistogramParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetHistogramParameterivCookie{cookie}
+}
+
+func (c *Conn) GlxGetHistogramParameterivUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetHistogramParameterivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetHistogramParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetHistogramParameterivCookie{cookie}
+}
+
+// Request reply for GlxGetHistogramParameteriv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetHistogramParameterivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetHistogramParameteriv
+func (cook GlxGetHistogramParameterivCookie) Reply() (*GlxGetHistogramParameterivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetHistogramParameterivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetHistogramParameteriv
+func glxGetHistogramParameterivReply(buf []byte) *GlxGetHistogramParameterivReply {
+ v := new(GlxGetHistogramParameterivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetHistogramParameterivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetHistogramParameteriv
+func (c *Conn) glxGetHistogramParameterivRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 156 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMinmax
+// size: 24
+type GlxGetMinmaxCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMinmax(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool, Reset bool) GlxGetMinmaxCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMinmaxRequest(ContextTag, Target, Format, Type, SwapBytes, Reset), cookie)
+ return GlxGetMinmaxCookie{cookie}
+}
+
+func (c *Conn) GlxGetMinmaxUnchecked(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool, Reset bool) GlxGetMinmaxCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMinmaxRequest(ContextTag, Target, Format, Type, SwapBytes, Reset), cookie)
+ return GlxGetMinmaxCookie{cookie}
+}
+
+// Request reply for GlxGetMinmax
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetMinmaxReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 24 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetMinmax
+func (cook GlxGetMinmaxCookie) Reply() (*GlxGetMinmaxReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMinmaxReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMinmax
+func glxGetMinmaxReply(buf []byte) *GlxGetMinmaxReply {
+ v := new(GlxGetMinmaxReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 24 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetMinmaxCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMinmax
+func (c *Conn) glxGetMinmaxRequest(ContextTag GlxContextTag, Target uint32, Format uint32, Type uint32, SwapBytes bool, Reset bool) []byte {
+ size := 24
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 157 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Format)
+ b += 4
+
+ Put32(buf[b:], Type)
+ b += 4
+
+ if SwapBytes {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ if Reset {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request GlxGetMinmaxParameterfv
+// size: 16
+type GlxGetMinmaxParameterfvCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMinmaxParameterfv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetMinmaxParameterfvCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMinmaxParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetMinmaxParameterfvCookie{cookie}
+}
+
+func (c *Conn) GlxGetMinmaxParameterfvUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetMinmaxParameterfvCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMinmaxParameterfvRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetMinmaxParameterfvCookie{cookie}
+}
+
+// Request reply for GlxGetMinmaxParameterfv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetMinmaxParameterfvReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum GlxFloat32
+ // padding: 12 bytes
+ Data []GlxFloat32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetMinmaxParameterfv
+func (cook GlxGetMinmaxParameterfvCookie) Reply() (*GlxGetMinmaxParameterfvReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMinmaxParameterfvReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMinmaxParameterfv
+func glxGetMinmaxParameterfvReply(buf []byte) *GlxGetMinmaxParameterfvReply {
+ v := new(GlxGetMinmaxParameterfvReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = GlxFloat32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]GlxFloat32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = GlxFloat32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMinmaxParameterfvCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMinmaxParameterfv
+func (c *Conn) glxGetMinmaxParameterfvRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 158 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetMinmaxParameteriv
+// size: 16
+type GlxGetMinmaxParameterivCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetMinmaxParameteriv(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetMinmaxParameterivCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetMinmaxParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetMinmaxParameterivCookie{cookie}
+}
+
+func (c *Conn) GlxGetMinmaxParameterivUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetMinmaxParameterivCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetMinmaxParameterivRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetMinmaxParameterivCookie{cookie}
+}
+
+// Request reply for GlxGetMinmaxParameteriv
+// size: (32 + pad((int(N) * 4)))
+type GlxGetMinmaxParameterivReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetMinmaxParameteriv
+func (cook GlxGetMinmaxParameterivCookie) Reply() (*GlxGetMinmaxParameterivReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetMinmaxParameterivReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetMinmaxParameteriv
+func glxGetMinmaxParameterivReply(buf []byte) *GlxGetMinmaxParameterivReply {
+ v := new(GlxGetMinmaxParameterivReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetMinmaxParameterivCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetMinmaxParameteriv
+func (c *Conn) glxGetMinmaxParameterivRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 159 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetCompressedTexImageARB
+// size: 16
+type GlxGetCompressedTexImageARBCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetCompressedTexImageARB(ContextTag GlxContextTag, Target uint32, Level int32) GlxGetCompressedTexImageARBCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetCompressedTexImageARBRequest(ContextTag, Target, Level), cookie)
+ return GlxGetCompressedTexImageARBCookie{cookie}
+}
+
+func (c *Conn) GlxGetCompressedTexImageARBUnchecked(ContextTag GlxContextTag, Target uint32, Level int32) GlxGetCompressedTexImageARBCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetCompressedTexImageARBRequest(ContextTag, Target, Level), cookie)
+ return GlxGetCompressedTexImageARBCookie{cookie}
+}
+
+// Request reply for GlxGetCompressedTexImageARB
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GlxGetCompressedTexImageARBReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 8 bytes
+ Size int32
+ // padding: 12 bytes
+ Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Waits and reads reply data from request GlxGetCompressedTexImageARB
+func (cook GlxGetCompressedTexImageARBCookie) Reply() (*GlxGetCompressedTexImageARBReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetCompressedTexImageARBReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetCompressedTexImageARB
+func glxGetCompressedTexImageARBReply(buf []byte) *GlxGetCompressedTexImageARBReply {
+ v := new(GlxGetCompressedTexImageARBReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 8 // padding
+
+ v.Size = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]byte, (int(v.Length) * 4))
+ copy(v.Data[:(int(v.Length)*4)], buf[b:])
+ b += pad(int((int(v.Length) * 4)))
+
+ return v
+}
+
+func (cook GlxGetCompressedTexImageARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetCompressedTexImageARB
+func (c *Conn) glxGetCompressedTexImageARBRequest(ContextTag GlxContextTag, Target uint32, Level int32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 160 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], uint32(Level))
+ b += 4
+
+ return buf
+}
+
+// Request GlxDeleteQueriesARB
+// size: pad((12 + pad((int(N) * 4))))
+type GlxDeleteQueriesARBCookie struct {
+ *cookie
+}
+
+// Write request to wire for GlxDeleteQueriesARB
+func (c *Conn) GlxDeleteQueriesARB(ContextTag GlxContextTag, N int32, Ids []uint32) GlxDeleteQueriesARBCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.glxDeleteQueriesARBRequest(ContextTag, N, Ids), cookie)
+ return GlxDeleteQueriesARBCookie{cookie}
+}
+
+func (c *Conn) GlxDeleteQueriesARBChecked(ContextTag GlxContextTag, N int32, Ids []uint32) GlxDeleteQueriesARBCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.glxDeleteQueriesARBRequest(ContextTag, N, Ids), cookie)
+ return GlxDeleteQueriesARBCookie{cookie}
+}
+
+func (cook GlxDeleteQueriesARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxDeleteQueriesARB
+func (c *Conn) glxDeleteQueriesARBRequest(ContextTag GlxContextTag, N int32, Ids []uint32) []byte {
+ size := pad((12 + pad((int(N) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 161 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(N))
+ b += 4
+
+ for i := 0; i < int(N); i++ {
+ Put32(buf[b:], Ids[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request GlxGenQueriesARB
+// size: 12
+type GlxGenQueriesARBCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGenQueriesARB(ContextTag GlxContextTag, N int32) GlxGenQueriesARBCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGenQueriesARBRequest(ContextTag, N), cookie)
+ return GlxGenQueriesARBCookie{cookie}
+}
+
+func (c *Conn) GlxGenQueriesARBUnchecked(ContextTag GlxContextTag, N int32) GlxGenQueriesARBCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGenQueriesARBRequest(ContextTag, N), cookie)
+ return GlxGenQueriesARBCookie{cookie}
+}
+
+// Request reply for GlxGenQueriesARB
+// size: (32 + pad((int(Length) * 4)))
+type GlxGenQueriesARBReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 24 bytes
+ Data []uint32 // size: pad((int(Length) * 4))
+}
+
+// Waits and reads reply data from request GlxGenQueriesARB
+func (cook GlxGenQueriesARBCookie) Reply() (*GlxGenQueriesARBReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGenQueriesARBReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGenQueriesARB
+func glxGenQueriesARBReply(buf []byte) *GlxGenQueriesARBReply {
+ v := new(GlxGenQueriesARBReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 24 // padding
+
+ v.Data = make([]uint32, v.Length)
+ for i := 0; i < int(v.Length); i++ {
+ v.Data[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGenQueriesARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGenQueriesARB
+func (c *Conn) glxGenQueriesARBRequest(ContextTag GlxContextTag, N int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 162 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], uint32(N))
+ b += 4
+
+ return buf
+}
+
+// Request GlxIsQueryARB
+// size: 12
+type GlxIsQueryARBCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxIsQueryARB(ContextTag GlxContextTag, Id uint32) GlxIsQueryARBCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxIsQueryARBRequest(ContextTag, Id), cookie)
+ return GlxIsQueryARBCookie{cookie}
+}
+
+func (c *Conn) GlxIsQueryARBUnchecked(ContextTag GlxContextTag, Id uint32) GlxIsQueryARBCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxIsQueryARBRequest(ContextTag, Id), cookie)
+ return GlxIsQueryARBCookie{cookie}
+}
+
+// Request reply for GlxIsQueryARB
+// size: 12
+type GlxIsQueryARBReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ RetVal GlxBool32
+}
+
+// Waits and reads reply data from request GlxIsQueryARB
+func (cook GlxIsQueryARBCookie) Reply() (*GlxIsQueryARBReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxIsQueryARBReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxIsQueryARB
+func glxIsQueryARBReply(buf []byte) *GlxIsQueryARBReply {
+ v := new(GlxIsQueryARBReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.RetVal = GlxBool32(Get32(buf[b:]))
+ b += 4
+
+ return v
+}
+
+func (cook GlxIsQueryARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxIsQueryARB
+func (c *Conn) glxIsQueryARBRequest(ContextTag GlxContextTag, Id uint32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 163 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Id)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetQueryivARB
+// size: 16
+type GlxGetQueryivARBCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetQueryivARB(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetQueryivARBCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetQueryivARBRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetQueryivARBCookie{cookie}
+}
+
+func (c *Conn) GlxGetQueryivARBUnchecked(ContextTag GlxContextTag, Target uint32, Pname uint32) GlxGetQueryivARBCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetQueryivARBRequest(ContextTag, Target, Pname), cookie)
+ return GlxGetQueryivARBCookie{cookie}
+}
+
+// Request reply for GlxGetQueryivARB
+// size: (32 + pad((int(N) * 4)))
+type GlxGetQueryivARBReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetQueryivARB
+func (cook GlxGetQueryivARBCookie) Reply() (*GlxGetQueryivARBReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetQueryivARBReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetQueryivARB
+func glxGetQueryivARBReply(buf []byte) *GlxGetQueryivARBReply {
+ v := new(GlxGetQueryivARBReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetQueryivARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetQueryivARB
+func (c *Conn) glxGetQueryivARBRequest(ContextTag GlxContextTag, Target uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 164 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Target)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetQueryObjectivARB
+// size: 16
+type GlxGetQueryObjectivARBCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetQueryObjectivARB(ContextTag GlxContextTag, Id uint32, Pname uint32) GlxGetQueryObjectivARBCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetQueryObjectivARBRequest(ContextTag, Id, Pname), cookie)
+ return GlxGetQueryObjectivARBCookie{cookie}
+}
+
+func (c *Conn) GlxGetQueryObjectivARBUnchecked(ContextTag GlxContextTag, Id uint32, Pname uint32) GlxGetQueryObjectivARBCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetQueryObjectivARBRequest(ContextTag, Id, Pname), cookie)
+ return GlxGetQueryObjectivARBCookie{cookie}
+}
+
+// Request reply for GlxGetQueryObjectivARB
+// size: (32 + pad((int(N) * 4)))
+type GlxGetQueryObjectivARBReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum int32
+ // padding: 12 bytes
+ Data []int32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetQueryObjectivARB
+func (cook GlxGetQueryObjectivARBCookie) Reply() (*GlxGetQueryObjectivARBReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetQueryObjectivARBReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetQueryObjectivARB
+func glxGetQueryObjectivARBReply(buf []byte) *GlxGetQueryObjectivARBReply {
+ v := new(GlxGetQueryObjectivARBReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = int32(Get32(buf[b:]))
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]int32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = int32(Get32(buf[b:]))
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetQueryObjectivARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetQueryObjectivARB
+func (c *Conn) glxGetQueryObjectivARBRequest(ContextTag GlxContextTag, Id uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 165 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Id)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}
+
+// Request GlxGetQueryObjectuivARB
+// size: 16
+type GlxGetQueryObjectuivARBCookie struct {
+ *cookie
+}
+
+func (c *Conn) GlxGetQueryObjectuivARB(ContextTag GlxContextTag, Id uint32, Pname uint32) GlxGetQueryObjectuivARBCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.glxGetQueryObjectuivARBRequest(ContextTag, Id, Pname), cookie)
+ return GlxGetQueryObjectuivARBCookie{cookie}
+}
+
+func (c *Conn) GlxGetQueryObjectuivARBUnchecked(ContextTag GlxContextTag, Id uint32, Pname uint32) GlxGetQueryObjectuivARBCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.glxGetQueryObjectuivARBRequest(ContextTag, Id, Pname), cookie)
+ return GlxGetQueryObjectuivARBCookie{cookie}
+}
+
+// Request reply for GlxGetQueryObjectuivARB
+// size: (32 + pad((int(N) * 4)))
+type GlxGetQueryObjectuivARBReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ // padding: 4 bytes
+ N uint32
+ Datum uint32
+ // padding: 12 bytes
+ Data []uint32 // size: pad((int(N) * 4))
+}
+
+// Waits and reads reply data from request GlxGetQueryObjectuivARB
+func (cook GlxGetQueryObjectuivARBCookie) Reply() (*GlxGetQueryObjectuivARBReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return glxGetQueryObjectuivARBReply(buf), nil
+}
+
+// Read reply into structure from buffer for GlxGetQueryObjectuivARB
+func glxGetQueryObjectuivARBReply(buf []byte) *GlxGetQueryObjectuivARBReply {
+ v := new(GlxGetQueryObjectuivARBReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ b += 4 // padding
+
+ v.N = Get32(buf[b:])
+ b += 4
+
+ v.Datum = Get32(buf[b:])
+ b += 4
+
+ b += 12 // padding
+
+ v.Data = make([]uint32, v.N)
+ for i := 0; i < int(v.N); i++ {
+ v.Data[i] = Get32(buf[b:])
+ b += 4
+ }
+ b = pad(b)
+
+ return v
+}
+
+func (cook GlxGetQueryObjectuivARBCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for GlxGetQueryObjectuivARB
+func (c *Conn) glxGetQueryObjectuivARBRequest(ContextTag GlxContextTag, Id uint32, Pname uint32) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["GLX"]
+ b += 1
+
+ buf[b] = 166 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(ContextTag))
+ b += 4
+
+ Put32(buf[b:], Id)
+ b += 4
+
+ Put32(buf[b:], Pname)
+ b += 4
+
+ return buf
+}