diff options
Diffstat (limited to 'nexgb/auto_glx.go')
| -rw-r--r-- | nexgb/auto_glx.go | 9356 |
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 +} |