// Code generated by xtgen; DO NOT EDIT.
package render

import "bnema.dev/xturbo/xproto"
import "encoding/binary"
import "math/bits"
import "bnema.dev/xturbo"

func QueryVersion(b *xturbo.Buf, clientMajorVersion uint32, clientMinorVersion uint32) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 0, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(clientMajorVersion))
	binary.LittleEndian.PutUint32(p[4:], uint32(clientMinorVersion))
	return seq
}

func QueryPictFormats(b *xturbo.Buf) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 1, 0)
	if p == nil {
		return 0
	}
	return seq
}

func QueryPictIndexValues(b *xturbo.Buf, format Pictformat) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 2, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(format))
	return seq
}

type CreatePictureValues struct {
	Mask             Cp
	Repeat           Repeat
	Alphamap         Picture
	Alphaxorigin     int32
	Alphayorigin     int32
	Clipxorigin      int32
	Clipyorigin      int32
	Clipmask         xproto.Pixmap
	Graphicsexposure uint32
	Subwindowmode    xproto.SubwindowMode
	Polyedge         PolyEdge
	Polymode         PolyMode
	Dither           xproto.Atom
	Componentalpha   uint32
}

func (v *CreatePictureValues) SetRepeat(x Repeat) *CreatePictureValues {
	v.Mask |= CpRepeat
	v.Repeat = x
	return v
}
func (v *CreatePictureValues) SetAlphamap(x Picture) *CreatePictureValues {
	v.Mask |= CpAlphaMap
	v.Alphamap = x
	return v
}
func (v *CreatePictureValues) SetAlphaxorigin(x int32) *CreatePictureValues {
	v.Mask |= CpAlphaXOrigin
	v.Alphaxorigin = x
	return v
}
func (v *CreatePictureValues) SetAlphayorigin(x int32) *CreatePictureValues {
	v.Mask |= CpAlphaYOrigin
	v.Alphayorigin = x
	return v
}
func (v *CreatePictureValues) SetClipxorigin(x int32) *CreatePictureValues {
	v.Mask |= CpClipXOrigin
	v.Clipxorigin = x
	return v
}
func (v *CreatePictureValues) SetClipyorigin(x int32) *CreatePictureValues {
	v.Mask |= CpClipYOrigin
	v.Clipyorigin = x
	return v
}
func (v *CreatePictureValues) SetClipmask(x xproto.Pixmap) *CreatePictureValues {
	v.Mask |= CpClipMask
	v.Clipmask = x
	return v
}
func (v *CreatePictureValues) SetGraphicsexposure(x uint32) *CreatePictureValues {
	v.Mask |= CpGraphicsExposure
	v.Graphicsexposure = x
	return v
}
func (v *CreatePictureValues) SetSubwindowmode(x xproto.SubwindowMode) *CreatePictureValues {
	v.Mask |= CpSubwindowMode
	v.Subwindowmode = x
	return v
}
func (v *CreatePictureValues) SetPolyedge(x PolyEdge) *CreatePictureValues {
	v.Mask |= CpPolyEdge
	v.Polyedge = x
	return v
}
func (v *CreatePictureValues) SetPolymode(x PolyMode) *CreatePictureValues {
	v.Mask |= CpPolyMode
	v.Polymode = x
	return v
}
func (v *CreatePictureValues) SetDither(x xproto.Atom) *CreatePictureValues {
	v.Mask |= CpDither
	v.Dither = x
	return v
}
func (v *CreatePictureValues) SetComponentalpha(x uint32) *CreatePictureValues {
	v.Mask |= CpComponentAlpha
	v.Componentalpha = x
	return v
}
func CreatePicture(b *xturbo.Buf, pid Picture, drawable xproto.Drawable, format Pictformat, v *CreatePictureValues) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 4, 16+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(pid))
	binary.LittleEndian.PutUint32(p[4:], uint32(drawable))
	binary.LittleEndian.PutUint32(p[8:], uint32(format))
	binary.LittleEndian.PutUint32(p[12:], uint32(v.Mask))
	off := 16
	if v.Mask&CpRepeat != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Repeat))
		off += 4
	}
	if v.Mask&CpAlphaMap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Alphamap))
		off += 4
	}
	if v.Mask&CpAlphaXOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Alphaxorigin))
		off += 4
	}
	if v.Mask&CpAlphaYOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Alphayorigin))
		off += 4
	}
	if v.Mask&CpClipXOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Clipxorigin))
		off += 4
	}
	if v.Mask&CpClipYOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Clipyorigin))
		off += 4
	}
	if v.Mask&CpClipMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Clipmask))
		off += 4
	}
	if v.Mask&CpGraphicsExposure != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Graphicsexposure))
		off += 4
	}
	if v.Mask&CpSubwindowMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Subwindowmode))
		off += 4
	}
	if v.Mask&CpPolyEdge != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Polyedge))
		off += 4
	}
	if v.Mask&CpPolyMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Polymode))
		off += 4
	}
	if v.Mask&CpDither != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Dither))
		off += 4
	}
	if v.Mask&CpComponentAlpha != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Componentalpha))
		off += 4
	}
	_ = off
	return seq
}

type ChangePictureValues struct {
	Mask             Cp
	Repeat           Repeat
	Alphamap         Picture
	Alphaxorigin     int32
	Alphayorigin     int32
	Clipxorigin      int32
	Clipyorigin      int32
	Clipmask         xproto.Pixmap
	Graphicsexposure uint32
	Subwindowmode    xproto.SubwindowMode
	Polyedge         PolyEdge
	Polymode         PolyMode
	Dither           xproto.Atom
	Componentalpha   uint32
}

func (v *ChangePictureValues) SetRepeat(x Repeat) *ChangePictureValues {
	v.Mask |= CpRepeat
	v.Repeat = x
	return v
}
func (v *ChangePictureValues) SetAlphamap(x Picture) *ChangePictureValues {
	v.Mask |= CpAlphaMap
	v.Alphamap = x
	return v
}
func (v *ChangePictureValues) SetAlphaxorigin(x int32) *ChangePictureValues {
	v.Mask |= CpAlphaXOrigin
	v.Alphaxorigin = x
	return v
}
func (v *ChangePictureValues) SetAlphayorigin(x int32) *ChangePictureValues {
	v.Mask |= CpAlphaYOrigin
	v.Alphayorigin = x
	return v
}
func (v *ChangePictureValues) SetClipxorigin(x int32) *ChangePictureValues {
	v.Mask |= CpClipXOrigin
	v.Clipxorigin = x
	return v
}
func (v *ChangePictureValues) SetClipyorigin(x int32) *ChangePictureValues {
	v.Mask |= CpClipYOrigin
	v.Clipyorigin = x
	return v
}
func (v *ChangePictureValues) SetClipmask(x xproto.Pixmap) *ChangePictureValues {
	v.Mask |= CpClipMask
	v.Clipmask = x
	return v
}
func (v *ChangePictureValues) SetGraphicsexposure(x uint32) *ChangePictureValues {
	v.Mask |= CpGraphicsExposure
	v.Graphicsexposure = x
	return v
}
func (v *ChangePictureValues) SetSubwindowmode(x xproto.SubwindowMode) *ChangePictureValues {
	v.Mask |= CpSubwindowMode
	v.Subwindowmode = x
	return v
}
func (v *ChangePictureValues) SetPolyedge(x PolyEdge) *ChangePictureValues {
	v.Mask |= CpPolyEdge
	v.Polyedge = x
	return v
}
func (v *ChangePictureValues) SetPolymode(x PolyMode) *ChangePictureValues {
	v.Mask |= CpPolyMode
	v.Polymode = x
	return v
}
func (v *ChangePictureValues) SetDither(x xproto.Atom) *ChangePictureValues {
	v.Mask |= CpDither
	v.Dither = x
	return v
}
func (v *ChangePictureValues) SetComponentalpha(x uint32) *ChangePictureValues {
	v.Mask |= CpComponentAlpha
	v.Componentalpha = x
	return v
}
func ChangePicture(b *xturbo.Buf, picture Picture, v *ChangePictureValues) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 5, 8+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(picture))
	binary.LittleEndian.PutUint32(p[4:], uint32(v.Mask))
	off := 8
	if v.Mask&CpRepeat != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Repeat))
		off += 4
	}
	if v.Mask&CpAlphaMap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Alphamap))
		off += 4
	}
	if v.Mask&CpAlphaXOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Alphaxorigin))
		off += 4
	}
	if v.Mask&CpAlphaYOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Alphayorigin))
		off += 4
	}
	if v.Mask&CpClipXOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Clipxorigin))
		off += 4
	}
	if v.Mask&CpClipYOrigin != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Clipyorigin))
		off += 4
	}
	if v.Mask&CpClipMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Clipmask))
		off += 4
	}
	if v.Mask&CpGraphicsExposure != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Graphicsexposure))
		off += 4
	}
	if v.Mask&CpSubwindowMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Subwindowmode))
		off += 4
	}
	if v.Mask&CpPolyEdge != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Polyedge))
		off += 4
	}
	if v.Mask&CpPolyMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Polymode))
		off += 4
	}
	if v.Mask&CpDither != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Dither))
		off += 4
	}
	if v.Mask&CpComponentAlpha != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Componentalpha))
		off += 4
	}
	_ = off
	return seq
}

func SetPictureClipRectangles(b *xturbo.Buf, picture Picture, clipXOrigin int16, clipYOrigin int16, rectangles []xproto.Rectangle) xturbo.Seq {
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(rectangles) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 6, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(picture))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(clipXOrigin))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(clipYOrigin))
	off += 2
	for i := range rectangles {
		rectangles[i].Put(p[off:])
		off += 8
	}
	return seq
}

func FreePicture(b *xturbo.Buf, picture Picture) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 7, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(picture))
	return seq
}

func Composite(b *xturbo.Buf, op PictOp, src Picture, mask Picture, dst Picture, srcX int16, srcY int16, maskX int16, maskY int16, dstX int16, dstY int16, width uint16, height uint16) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 8, 32)
	if p == nil {
		return 0
	}
	p[0:][0] = byte(op)
	binary.LittleEndian.PutUint32(p[4:], uint32(src))
	binary.LittleEndian.PutUint32(p[8:], uint32(mask))
	binary.LittleEndian.PutUint32(p[12:], uint32(dst))
	binary.LittleEndian.PutUint16(p[16:], uint16(srcX))
	binary.LittleEndian.PutUint16(p[18:], uint16(srcY))
	binary.LittleEndian.PutUint16(p[20:], uint16(maskX))
	binary.LittleEndian.PutUint16(p[22:], uint16(maskY))
	binary.LittleEndian.PutUint16(p[24:], uint16(dstX))
	binary.LittleEndian.PutUint16(p[26:], uint16(dstY))
	binary.LittleEndian.PutUint16(p[28:], uint16(width))
	binary.LittleEndian.PutUint16(p[30:], uint16(height))
	return seq
}

func Trapezoids(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, srcX int16, srcY int16, traps []Trapezoid) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(traps) * 40
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 10, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	for i := range traps {
		traps[i].Put(p[off:])
		off += 40
	}
	return seq
}

func Triangles(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, srcX int16, srcY int16, triangles []Triangle) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(triangles) * 24
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 11, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	for i := range triangles {
		triangles[i].Put(p[off:])
		off += 24
	}
	return seq
}

func TriStrip(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, srcX int16, srcY int16, points []Pointfix) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(points) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 12, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	for i := range points {
		points[i].Put(p[off:])
		off += 8
	}
	return seq
}

func TriFan(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, srcX int16, srcY int16, points []Pointfix) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(points) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 13, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	for i := range points {
		points[i].Put(p[off:])
		off += 8
	}
	return seq
}

func CreateGlyphSet(b *xturbo.Buf, gsid Glyphset, format Pictformat) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 17, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(gsid))
	binary.LittleEndian.PutUint32(p[4:], uint32(format))
	return seq
}

func ReferenceGlyphSet(b *xturbo.Buf, gsid Glyphset, existing Glyphset) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 18, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(gsid))
	binary.LittleEndian.PutUint32(p[4:], uint32(existing))
	return seq
}

func FreeGlyphSet(b *xturbo.Buf, glyphset Glyphset) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 19, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(glyphset))
	return seq
}

func AddGlyphs(b *xturbo.Buf, glyphset Glyphset, glyphsLen uint32, glyphids []uint32, glyphs []Glyphinfo, data []byte) xturbo.Seq {
	if len(glyphids) != int(glyphsLen) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	if len(glyphs) != int(glyphsLen) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += len(glyphids) * 4
	size += len(glyphs) * 12
	size += len(data) * 1
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 20, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(glyphset))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(glyphsLen))
	off += 4
	for i := range glyphids {
		binary.LittleEndian.PutUint32(p[off:], uint32(glyphids[i]))
		off += 4
	}
	for i := range glyphs {
		glyphs[i].Put(p[off:])
		off += 12
	}
	copy(p[off:], data)
	off += len(data)
	return seq
}

func FreeGlyphs(b *xturbo.Buf, glyphset Glyphset, glyphs []Glyph) xturbo.Seq {
	size := 0
	size += 4
	size += len(glyphs) * 4
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 22, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(glyphset))
	off += 4
	for i := range glyphs {
		binary.LittleEndian.PutUint32(p[off:], uint32(glyphs[i]))
		off += 4
	}
	return seq
}

func CompositeGlyphs8(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, glyphset Glyphset, srcX int16, srcY int16, glyphcmds []byte) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(glyphcmds) * 1
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 23, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(glyphset))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	copy(p[off:], glyphcmds)
	off += len(glyphcmds)
	return seq
}

func CompositeGlyphs16(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, glyphset Glyphset, srcX int16, srcY int16, glyphcmds []byte) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(glyphcmds) * 1
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 24, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(glyphset))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	copy(p[off:], glyphcmds)
	off += len(glyphcmds)
	return seq
}

func CompositeGlyphs32(b *xturbo.Buf, op PictOp, src Picture, dst Picture, maskFormat Pictformat, glyphset Glyphset, srcX int16, srcY int16, glyphcmds []byte) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 4
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(glyphcmds) * 1
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 25, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(maskFormat))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(glyphset))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(srcX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(srcY))
	off += 2
	copy(p[off:], glyphcmds)
	off += len(glyphcmds)
	return seq
}

func FillRectangles(b *xturbo.Buf, op PictOp, dst Picture, color Color, rects []xproto.Rectangle) xturbo.Seq {
	size := 0
	size += 1
	size += 3
	size += 4
	size += 8
	size += len(rects) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 26, size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(op)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(dst))
	off += 4
	color.Put(p[off:])
	off += 8
	for i := range rects {
		rects[i].Put(p[off:])
		off += 8
	}
	return seq
}

func CreateCursor(b *xturbo.Buf, cid xproto.Cursor, source Picture, x uint16, y uint16) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 27, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cid))
	binary.LittleEndian.PutUint32(p[4:], uint32(source))
	binary.LittleEndian.PutUint16(p[8:], uint16(x))
	binary.LittleEndian.PutUint16(p[10:], uint16(y))
	return seq
}

func SetPictureTransform(b *xturbo.Buf, picture Picture, transform Transform) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 28, 40)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(picture))
	transform.Put(p[4:])
	return seq
}

func QueryFilters(b *xturbo.Buf, drawable xproto.Drawable) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 29, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(drawable))
	return seq
}

func SetPictureFilter(b *xturbo.Buf, picture Picture, filter string, values []Fixed) xturbo.Seq {
	if uint64(len(filter)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(filter) * 1
	size = (size + 3) &^ 3
	size += len(values) * 4
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 30, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(picture))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(filter)))
	off += 2
	off += 2
	copy(p[off:], filter)
	off += len(filter)
	off = (off + 3) &^ 3
	for i := range values {
		binary.LittleEndian.PutUint32(p[off:], uint32(values[i]))
		off += 4
	}
	return seq
}

func CreateAnimCursor(b *xturbo.Buf, cid xproto.Cursor, cursors []Animcursorelt) xturbo.Seq {
	size := 0
	size += 4
	size += len(cursors) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 31, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cid))
	off += 4
	for i := range cursors {
		cursors[i].Put(p[off:])
		off += 8
	}
	return seq
}

func AddTraps(b *xturbo.Buf, picture Picture, xOff int16, yOff int16, traps []Trap) xturbo.Seq {
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(traps) * 24
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 32, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(picture))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(xOff))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(yOff))
	off += 2
	for i := range traps {
		traps[i].Put(p[off:])
		off += 24
	}
	return seq
}

func CreateSolidFill(b *xturbo.Buf, picture Picture, color Color) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 33, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(picture))
	color.Put(p[4:])
	return seq
}

func CreateLinearGradient(b *xturbo.Buf, picture Picture, p1 Pointfix, p2 Pointfix, numStops uint32, stops []Fixed, colors []Color) xturbo.Seq {
	if len(stops) != int(numStops) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	if len(colors) != int(numStops) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 8
	size += 8
	size += 4
	size += len(stops) * 4
	size += len(colors) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 34, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(picture))
	off += 4
	p1.Put(p[off:])
	off += 8
	p2.Put(p[off:])
	off += 8
	binary.LittleEndian.PutUint32(p[off:], uint32(numStops))
	off += 4
	for i := range stops {
		binary.LittleEndian.PutUint32(p[off:], uint32(stops[i]))
		off += 4
	}
	for i := range colors {
		colors[i].Put(p[off:])
		off += 8
	}
	return seq
}

func CreateRadialGradient(b *xturbo.Buf, picture Picture, inner Pointfix, outer Pointfix, innerRadius Fixed, outerRadius Fixed, numStops uint32, stops []Fixed, colors []Color) xturbo.Seq {
	if len(stops) != int(numStops) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	if len(colors) != int(numStops) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 8
	size += 8
	size += 4
	size += 4
	size += 4
	size += len(stops) * 4
	size += len(colors) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 35, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(picture))
	off += 4
	inner.Put(p[off:])
	off += 8
	outer.Put(p[off:])
	off += 8
	binary.LittleEndian.PutUint32(p[off:], uint32(innerRadius))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(outerRadius))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(numStops))
	off += 4
	for i := range stops {
		binary.LittleEndian.PutUint32(p[off:], uint32(stops[i]))
		off += 4
	}
	for i := range colors {
		colors[i].Put(p[off:])
		off += 8
	}
	return seq
}

func CreateConicalGradient(b *xturbo.Buf, picture Picture, center Pointfix, angle Fixed, numStops uint32, stops []Fixed, colors []Color) xturbo.Seq {
	if len(stops) != int(numStops) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	if len(colors) != int(numStops) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 8
	size += 4
	size += 4
	size += len(stops) * 4
	size += len(colors) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtRender)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 36, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(picture))
	off += 4
	center.Put(p[off:])
	off += 8
	binary.LittleEndian.PutUint32(p[off:], uint32(angle))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(numStops))
	off += 4
	for i := range stops {
		binary.LittleEndian.PutUint32(p[off:], uint32(stops[i]))
		off += 4
	}
	for i := range colors {
		colors[i].Put(p[off:])
		off += 8
	}
	return seq
}