gpu

type Batch struct {
	Start, Count int
	Scissor      Scissor
	// Image is the renderer's texture of the batch's image, or 0.
	Image uintptr
	// ClipMask is a cached nested clip texture, sampled in frame coordinates.
	ClipMask uintptr
	// Effect is the effect of the batch's one instance, drawn with a
	// pipeline of its own, and Backdrop, unless 0, 1 + the index in
	// Builder.Backdrops of its backdrop, which the renderer reads before
	// drawing it.
	Effect   *scene.Effect
	Backdrop int
	// Shader is the effect's op, for a shader's (Effect.Shader), and
	// Textures the renderer's textures of its images, 0 for none.
	Shader   *scene.EffectOp
	Textures [4]uintptr
	// Uniforms are the words of the shader's uniforms the batch draws
	// with: the op's, or its wide ones for a wide gamut (Wide).
	Uniforms []uint32
	// Hole tells that the batch's instances make their shapes transparent
	// (scene.OpHole): renderers blend them with a source factor of zero.
	Hole bool
	// Opaque tells that every fragment the batch's instances draw within
	// its scissor rectangle is opaque, with coverage exactly 1 (the cores of
	// opaque fills, see addOpaque): renderers may draw it without blending,
	// which writes the same bytes, and which lets a tile-based GPU
	// discard whatever it drew under them before shading it.
	Opaque bool
	// Class is the paths of the shader that the batch's instances need
	// (see Class), and Continuous whether any of them has continuous
	// corners, in its shape or in the clip the shader cuts; renderers that do
	// not specialize their shader ignore them.
	Class      Class
	Continuous bool
}

type Builder struct {
	Instances []Instance
	Batches   []Batch
	Backdrops []scene.Backdrop
	// Stops holds the stops of the gradients the instances draw with
	// (scene.Stop), two RGBA texels of 32-bit floats each, StopsWidth to
	// a row: the color, straight sRGB, then its place and its color in
	// Oklab. An instance painting with stops has the first's index and
	// how many in Color2.
	Stops []float32
	// BlurredImage, unless nil, returns the texture of an image's area
	// blurred as bk says (scene.ImageBlur), bk.Size() texels, rows going
	// down, which the renderer computes before the frame's pass: the
	// image's texture averaged over squares, blurred along rows and along
	// columns (ImageDownPass, ImageBlurPass). Without it, images draw
	// unblurred.
	BlurredImage func(img *scene.Image, bk scene.Backdrop) uintptr
	// Wide draws the colors of scenes outside the sRGB gamut
	// (Scene.Wide), for a target that keeps them, as Metal's float16
	// drawables do; without it, their nearest sRGB colors.
	Wide bool
	// NoShadowSplit draws every shadow as one instance, for comparison tests.
	NoShadowSplit bool
	// NoRingSplit draws every border-only fill as one instance (see
	// addFill), for tests that compare the two.
	NoRingSplit bool
	// NoClasses puts every batch in ClassGeneral, for tests and
	// measurements that compare the specialized shaders with the general one.
	NoClasses bool
	// Classes separates batches for renderers with specialized fragment shaders.
	Classes bool
	// GeneralClasses has a bit (1 << Class) for each class that draws with the
	// general shader, for tests that find which specialized one differs.
	GeneralClasses uint32
	// Opaque lets large opaque fills be drawn as an opaque core with blended
	// edges around it (see addOpaque), which a renderer sets that gains from
	// drawing the cores without blending (Metal's tile-based GPUs: hidden
	// surfaces are discarded): the others would only draw more calls for the
	// same pixels. Tests and measurements switch it to compare the two.
	Opaque bool
	// NoCull draws every op, even those that later opaque fills cover whole
	// (see planCull), for tests that compare the two.
	NoCull bool
	// GeneralFill makes the shaders take their general path for every fill,
	// and NoClipSkip makes them compute the clip's coverage where it is 1
	// (see markFill), for tests and measurements that compare them.
	GeneralFill, NoClipSkip bool
	// ClipSkip enables the clip-coverage flag understood by the Metal shader.
	ClipSkip bool
	// Culled is how many ops the last Build left out as covered.
	Culled, OpaqueCores int
	// contains filtered or unexported fields
}

type Class uint8

type Instance struct {
	// Rect is x, y, width, height; Radii the corners' radii (top-left,
	// top-right, bottom-right, bottom-left), negative for continuous
	// corners (scene.Corners), which only Metal's shader draws, or a
	// glyph's gamma ratios
	// (scene.TextParams); Inner those of a border's inner edge, or of the
	// box casting a shadow, or a glyph's contrast and thin boost in Inner[0]
	// and Inner[1].
	Rect, Radii, Inner [4]float32
	// Color and Color2 (a gradient's end) and Border are straight RGBA;
	// Color tints an image (white for none).
	Color, Color2, Border [4]float32
	// Grad holds a gradient's start and end points, or the stripes' unit
	// vector across them, width and period; UV the texture rectangle,
	// normalized, a fill's border widths (top, right, bottom, left), or
	// the box casting a shadow, which shows only outside it (none when
	// empty).
	//
	// An effect has its parameters (scene.EffectOp.Params) in Inner,
	// Color, Color2, Border and Grad, and in UV where its backdrop's area
	// starts in the frame and its size in texels.
	Grad, UV [4]float32
	// Clip and ClipRadii are the innermost clip, which the shader cuts.
	Clip, ClipRadii [4]float32
	// Params is the kind (0 fill, 1 shadow, 2 mask glyph, 3 color glyph, 4
	// image, 5 subpixel glyph, 6 effect); 1 for a dashed border, a
	// grayscale image or an inner shadow, whose box is in Rect and Radii
	// and the hole it leaves in UV and Inner (none when empty); the
	// shadow's sigma (0 for none), the paint (scene.Paint), 1 for an image
	// sampled at its nearest texel, or the size of the squares an effect's
	// backdrop averages; and the opacity.
	Params [4]float32
	// Transform rows map local pixels to the frame. Transform0.w enables
	// transformed antialiasing, Transform1.w selects how the clip applies: 0
	// the clip rectangle cut by the shader, 1 a cached clip mask, 2 a hard
	// clip over a masked one, and 3 none, as the builder found the clip's
	// rectangle to hold the whole quad with room for the antialiasing (see
	// markFill): the shaders then skip computing it.
	// Transform2 holds the projective row's g and h, the frame point of
	// local (x, y) being Transform0's and Transform1's dot products with
	// (x, y, 1) over g*x + h*y + 1: shaders interpolate in perspective.
	Transform0, Transform1, Transform2 [4]float32
}

type Pass struct {
	Origin, Limit, Shift, Dir [2]int32
	Down, Radius              int32
	Sigma                     float32
	// Mode is PassClear for passes reading an image to blur (scene.Op's
	// Blur), and PassUnflipped for those of OpenGL reading an image whose
	// rows go down.
	Mode int32
}

type Scissor struct{ Left, Top, Right, Bottom int32 }