gfx

type AlphaMode uint8

type BlendEq uint8

type BlendOp uint8

type BlendState struct {
	// The constant blend color to be used (e.g. with BConstantColor).
	Color Color

	// Specifies the blend operand to use for the source RGB components.
	// All predefined BlendOp constants may be used.
	SrcRGB BlendOp

	// Specifies the blend operand to use for the destination RGB components.
	// All predefined BlendOp constants may be used except BSrcAlphaSaturate.
	DstRGB BlendOp

	// Specifies the blending operation to use between source and destination
	// alpha components.
	SrcAlpha, DstAlpha BlendOp

	// Specifies the blending equation to use for RGB and Alpha components,
	// respectively.
	RGBEq, AlphaEq BlendEq
}

type Boundable interface {
	// Bounds returns the axis-aligned bounding box of this boundable object.
	Bounds() lmath.Rect3
}

type Bounds lmath.Rect3

type Camera interface {
	Transformable

	// Update should be called before using the camera (e.g. at the start of
	// the frame). It is used to make the camera aware of the rectangle it is
	// drawing to on the screen.
	Update(b image.Rectangle)

	// Projection should return the camera's projection matrix. The matrix is
	// responsible for projecting world coordinates into normalized device
	// coordinates (-1, -1) to (+1, +1).
	Projection() Mat4
}

type Canvas interface {
	Downloadable

	// SetMSAA should request that this canvas use multi-sample anti-aliasing
	// during drawing. By default MSAA is enabled.
	//
	// Even if MSAA is requested to be enabled, there is no guarantee that it
	// will actually be used. For instance if the device does not support it.
	SetMSAA(enabled bool)

	// MSAA returns the last value passed into SetMSAA on this canvas.
	MSAA() bool

	// Precision should return the precision of the canvas's color, depth, and
	// stencil buffers.
	Precision() Precision

	// Bounds should return the bounding rectangle of this canvas, any and all
	// methods of this canvas that take rectangles as parameters will be
	// clamped to these bounds.
	//
	// The bounds that this method returns may change over time (e.g. when a
	// user resizes the window).
	Bounds() image.Rectangle

	// Clear submits a clear operation to the canvas. It will clear the given
	// rectangle of the canvas's color buffer to the specified background
	// color.
	//
	// If the rectangle is empty this function is no-op.
	Clear(r image.Rectangle, bg Color)

	// ClearDepth submits a depth-clear operation to the canvas. It will clear
	// the given rectangle of the canvas's depth buffer to the specified depth
	// value (in the range of 0.0 to 1.0, where 1.0 is furthest away).
	//
	// If the rectangle is empty this function is no-op.
	ClearDepth(r image.Rectangle, depth float64)

	// ClearStencil submits a stencil-clear operation to the canvas. It will
	// clear the given rectangle of the canvas's stencil buffer to the
	// specified stencil value.
	//
	// If the rectangle is empty this function is no-op.
	ClearStencil(r image.Rectangle, stencil int)

	// Draw submits a draw operation to the canvas. It will draw the given
	// graphics object onto the specified rectangle of the canvas.
	//
	// Upon calling this method, ownership of the graphics object is given to
	// the canvas itself and you may no longer access it safely until the
	// canvas gives ownership of the object back to you.
	//
	// The canvas returns owernship of the object via the channel, if done !=
	// nil, or more effectively after Render has returned.
	//
	// If not nil, then the object is drawn according to how it is seen by the
	// given projector (e.g. camera), taking into account the projector's
	// projection and transformation matrices.
	//
	// If the GPU supports occlusion queries (see GPUInfo.OcclusionQuery) and
	// o.OcclusionTest is set to true then at some point in the future (or when
	// QueryWait() is called) the native object will record the number of
	// samples that passed depth and stencil testing phases such that when
	// SampleCount() is called it will return the number of samples last drawn
	// by the object.
	//
	// The canvas must invoke o.Bounds() some time before clearing data slices
	// of loaded meshes, such that the object has a chance to determine it's
	// bounding box.
	//
	// The object will not be drawn if any of the following cases are true:
	//
	//  o.State == nil
	//  o.Shader == nil
	//  len(o.Shader.Error) > 0
	//  len(o.Meshes) == 0
	//  !o.Meshes[N].Loaded && len(o.Meshes[N].Vertices) == 0
	//  !o.Textures[n].Loaded && o.Textures[N].Source == nil
	//
	// If the rectangle is empty this function is no-op.
	Draw(r image.Rectangle, o *Object, c Camera)

	// QueryWait blocks until all pending draw object's occlusion queries
	// completely finish. Most clients should avoid this call as it can easilly
	// cause graphics pipeline stalls if not handled with care.
	//
	// Instead of calling QueryWait immediately for conditional drawing, it is
	// common practice to instead make use of the previous frame's occlusion
	// query results as this allows the CPU and GPU to work in parralel instead
	// of being directly synchronized with one another.
	//
	// If the GPU does not support occlusion queries (see DeviceInfo's
	// OcclusionQuery field) then this function is no-op.
	QueryWait()

	// Render should finalize all pending clear and draw operations as if they
	// where all submitted over a single channel like so:
	//
	//  pending := len(ops)
	//  for i := 0; i < pending; i++ {
	//      op := <-ops
	//      finalize(op)
	//  }
	//
	// and once complete the final frame should be sent to the graphics
	// hardware for rasterization.
	//
	// Additionally, a call to Render() means an implicit call to QueryWait().
	Render()
}

type Cmp uint8

type Color struct {
	R, G, B, A float32
}

type CoordConv uint8

type DSFormat uint8

type Destroyable interface {
	// Destroy destroys this object. Once destroyed the object can still be
	// used but doing so is not advised for performance reasons (e.g. it
	// requires reloading the entire object).
	//
	// Destroy can be called any number of times and safely from multiple
	// goroutines concurrently.
	Destroy()
}

type Device interface {
	// The base canvas of the device (typically the window on the screen). The
	// canvas, like all other canvases, must not be accessed from multiple
	// goroutines concurrently.
	Canvas

	// Clock should return the graphics clock object which monitors the time
	// between frames, etc. The device is responsible for ticking it every
	// time a frame is rendered.
	Clock() *clock.Clock

	// Info should return information about the graphics hardware.
	Info() DeviceInfo

	// LoadMesh should begin loading the specified mesh asynchronously.
	//
	// Additionally, the device will set m.Loaded to true, and then invoke
	// m.ClearData(), thus allowing the data slices to be garbage collected).
	//
	// When the mesh is fully loaded, it is sent to the done channel if != nil,
	// and as long as sending would not block (i.e. ensure a buffer size of at
	// least one).
	//
	// Upon calling this method, ownership of the mesh is transferred to the
	// device itself and you may no longer access it safely until the device
	// passes ownership back to you over the done channel.
	LoadMesh(m *Mesh, done chan *Mesh)

	// LoadTexture should begin loading the specified texture asynchronously.
	//
	// Additionally, the device will set t.Loaded to true, and then invoke
	// t.ClearData(), thus allowing the source image to be garbage collected.
	//
	// When the texture is fully loaded, it is sent to the done channel
	// if != nil, and as long as sending would not block (i.e. ensure a buffer
	// size of at least one).
	//
	// Upon calling this method, ownership of the mesh is transferred to the
	// device itself and you may no longer access it safely until the device
	// passes ownership back to you over the done channel.
	LoadTexture(t *Texture, done chan *Texture)

	// LoadShader should begin loading the specified shader asynchronously.
	//
	// Additionally, if the shader was successfully loaded (no error log was
	// written) then the device will set s.Loaded to true, and then invoke
	// s.ClearData(), thus allowing the source data slices to be garbage
	// collected.
	//
	// When the shader is fully loaded (or has an error), it is sent to the
	// done channel if != nil, and as long as sending would not block (i.e.
	// ensure a buffer size of at least one).
	//
	// Upon calling this method, ownership of the shader is transferred to the
	// device itself and you may no longer access it safely until the device
	// passes ownership back to you over the done channel.
	LoadShader(s *Shader, done chan *Shader)

	// RenderToTexture creates and returns a canvas that when drawn to, stores
	// the results into one or multiple of the three textures (Color, Depth,
	// Stencil) of the given configuration.
	//
	// If the any of the configuration's formats are not supported by the
	// graphics hardware (i.e. not in GPUInfo.RTTFormats), then nil is
	// returned.
	//
	// If the given configuration is not valid (see the cfg.Valid method) then
	// a panic will occur.
	//
	// Any non-nil texture in the configuration will be set to loaded, will
	// have ClearData() called on it, and will have it's bounds set to
	// cfg.Bounds.
	RenderToTexture(cfg RTTConfig) Canvas
}

type DeviceInfo struct {
	// GL is a pointer to information about the OpenGL implementation, if the
	// device is a OpenGL device. Otherwise it is nil.
	GL *GLInfo

	// GLSL is a pointer to information about the GLSL implementation, if the
	// device is a OpenGL device. Otherwise it is nil.
	GLSL *GLSLInfo

	// MaxTextureSize is the maximum size of either X or Y dimension of texture
	// images for use with the device, or -1 if not available.
	MaxTextureSize int

	// Whether or not the AlphaToCoverage alpha mode is supported (if false
	// then BinaryAlpha will automatically be used as a fallback).
	AlphaToCoverage bool

	// Whether or not rendering objects with the DepthClamp state enabled is
	// supported.
	DepthClamp bool

	// Whether or not occlusion queries are supported or not.
	OcclusionQuery bool

	// The number of bits reserved for the sample count when performing
	// occlusion queries, if the number goes above what this many bits could
	// store then it is generally (but not always) clamped to that value.
	//
	// Some devices (e.g. OpenGL ES ones without certain extensions) only
	// support boolean occlusion queries (i.e. you can only tell if some
	// samples passed, but not how many specifically).
	OcclusionQueryBits int

	// The name of the graphics hardware, or an empty string if not available.
	// For example it may look something like:
	//
	//  Mesa DRI Intel(R) Sandybridge Mobile
	//
	Name string

	// The vendor name of the graphics hardware, or an empty string if not
	// available. For example:
	//
	//  Intel Open Source Technology Center
	//
	Vendor string

	// Whether or not the graphics hardware supports Non Power Of Two texture
	// sizes.
	//
	// If true, then textures may be any arbitrary size (while keeping in mind
	// this often incurs a performance cost, and does not work well with
	// compression or mipmapping).
	//
	// If false, then texture dimensions must be a power of two (e.g. 32x64,
	// 512x512, etc) or else the texture will be resized by the device to the
	// nearest power-of-two.
	NPOT bool

	// The formats available for render-to-texture (RTT).
	RTTFormats

	// Whether or not the graphics hardware supports the use of the BorderColor
	// TexWrap mode. If the hardware doesn't support it the device falls back
	// to the Clamp TexWrap mode in it's place.
	//
	// (Mobile) OpenGL ES 2 never supports BorderColor.
	//
	// (Desktop) OpenGL 2 always supports BorderColor.
	TexWrapBorderColor bool
}

type Downloadable interface {
	// Download should download the given intersecting rectangle of this
	// downloadable image from the graphics hardware into system memory and
	// send it to the complete channel when done.
	//
	// If downloading this texture is impossible (i.e. hardware does not
	// support this) then nil will be sent over the channel and all future
	// attempts to download this texture will fail as well.
	//
	// It should be noted that the downloaded image may not be pixel-identical
	// to the previously uploaded source image of a texture, for instance if
	// texture compression was used it may suffer from compression artifacts,
	// etc.
	//
	// Only a texture created from render-to-texture is guaranteed to succeed,
	// others may not (esp. compressed textures). Most devices support
	// downloading RGB/A textures and some support depth/alpha ones.
	Download(r image.Rectangle, complete chan image.Image)
}

type FaceCullMode uint8

type GLInfo struct {
	// Major, minor, and release versions of the OpenGL version in use. For
	// example:
	//
	//  // OpenGL v2.1.3
	//  MajorVersion: 2
	//  MinorVersion: 1
	//  ReleaseVersion: 3
	//
	MajorVersion, MinorVersion, ReleaseVersion int

	// VendorVersion is a vendor/manufacturer specific version string. It can
	// be anything at all (and sometimes nothing), but is typically the driver
	// version in use. For example:
	//
	//  "Mesa 10.5.0-devel (git-b3721cd 2014-11-26 trusty-oibaf-ppa)"
	//  ""
	//
	VendorVersion string

	// A read-only slice of OpenGL extension strings.
	Extensions []string
}

type GLSLInfo struct {
	// Major, minor, and release versions of the OpenGL Shading Language
	// version present. For example:
	//
	//  // GLSL v1.30.2
	//  MajorVersion: 1
	//  MinorVersion: 30
	//  ReleaseVersion: 2
	//
	MajorVersion, MinorVersion, ReleaseVersion int

	// MaxVaryingFloats is the number of floating-point varying variables
	// available inside GLSL programs.
	//
	// Generally at least 32.
	MaxVaryingFloats int

	// MaxVertexInputs is the maximum number of vertex shader inputs (i.e.
	// floating-point values, where a 4x4 matrix is 16 floating-point values).
	//
	// Generally at least 512.
	MaxVertexInputs int

	// MaxFragmentInputs is the maximum number of fragment shader inputs (i.e.
	// floating-point values, where a 4x4 matrix is 16 floating-point values).
	//
	// Generally at least 64.
	MaxFragmentInputs int
}

type GLSLSources struct {
	// The GLSL vertex shader source code.
	Vertex []byte

	// The GLSL fragment shader source code.
	Fragment []byte
}

type Mat4 [4][4]float32

type Mesh struct {
	// The native object of this mesh. Once the mesh is loaded by a device this
	// field will be initialized by the device. Only device implementations
	// should assign values to this field.
	NativeMesh Destroyable

	// Weather or not this mesh is currently loaded or not.
	Loaded bool

	// The primitive type of this mesh. The zero-value (i.e. default value) is
	// Triangles.
	Primitive

	// If true then when this mesh is loaded the sources of it will be kept
	// instead of being set to nil (which allows them to be garbage collected).
	KeepDataOnLoad bool

	// Dynamic is a hint (it does not restrict how the mesh may be used) to the
	// graphics device on how this mesh might be used. If you intend to update
	// mesh data often (i.e. it's not static) then set this to true.
	Dynamic bool

	// AABB is the axis aligned bounding box of this mesh. There may not be one
	// if AABB.Empty() == true, but one can be calculate using the
	// CalculateBounds() method.
	AABB lmath.Rect3

	// A slice of indices, if non-nil then this slice contains indices into
	// each other slice (such as Vertices) and this is a indexed mesh.
	//
	// The indices are uint32 (instead of int) for compatability with graphics
	// hardware.
	Indices []uint32

	// Weather or not the indices have changed since the last time the mesh
	// was loaded. If set to true the device should take note and re-upload the
	// data slice to the graphics hardware.
	IndicesChanged bool

	// The slice of vertices for the mesh.
	Vertices []Vec3

	// Weather or not the vertices have changed since the last time the
	// mesh was loaded. If set to true the device should take note and
	// re-upload the data slice to the graphics hardware.
	VerticesChanged bool

	// The slice of vertex colors for the mesh.
	Colors []Color

	// Weather or not the vertex colors have changed since the last time
	// the mesh was loaded. If set to true the device should take note
	// and re-upload the data slice to the graphics hardware.
	ColorsChanged bool

	// The slice of normals for the mesh.
	Normals []Vec3

	// Weather or not the normals have changed since the last time the
	// mesh was loaded. If set to true the device should take note and
	// re-upload the data slice to the graphics hardware.
	NormalsChanged bool

	// A slice of barycentric coordinates for the mesh.
	Bary []Vec3

	// Whether or not the barycentric coordinates have changed since the last
	// time the mesh was loaded. If set to true the device should take note
	// and re-upload the data slice to the graphics hardware.
	BaryChanged bool

	// A slice of texture coordinate sets for the mesh, there may be
	// multiple sets which directly relate to multiple textures on a
	// object.
	TexCoords []TexCoordSet

	// A map of custom per-vertex attributes for the mesh. It is analogous to
	// the Colors, Bary, and TexCoords fields. It allows you to submit a set of
	// named custom per-vertex data to shaders.
	//
	// For instance you could submit a set of per-vertex vec3's with:
	//  myData := make([]gfx.Vec3, len(mesh.Vertices))
	//  mesh.Attribs["MyName"] = gfx.VertexAttrib{
	//      Data: myData,
	//  }
	//
	// If changes to the data are made, the data set will have to be uploaded
	// to the graphics hardware again, so you must inform the device when you
	// change the data:
	//  ... modify myData ...
	//  mesh.Attribs["MyName"].Changed = true
	//
	// In GLSL you could access that per-vertex data by writing:
	//  attribute vec3 MyName;
	//
	// Arrays of data are available in GLSL by slice indice suffixes:
	//  // Data declared in Go:
	//  myData := make([][]gfx.Mat4, 2)
	//
	//  // And in GLSL:
	//  attribute mat4 MyName0; // Per-vertex data from myData[0].
	//  attribute mat4 MyName1; // Per-vertex data from myData[1].
	//
	// See the documentation on the VertexAttrib type for more information
	// regarding what data types may be used.
	Attribs map[string]VertexAttrib
}

type MeshState struct {
	// Whether or not indices, vertices, etc are present in the mesh.
	Indices, Vertices, Colors, Normals, Bary bool

	// How many texture coordinate sets are present in the mesh. The boolean
	// value signifies whether the len(texCoord.Slice) > 0 or not.
	TexCoords []bool

	// A map of attribute names to boolean values signifying whether the
	// len(attrib.Data) > 0 or not.
	Attribs map[string]bool
}

type NativeObject interface {
	Destroyable

	// If the GPU supports occlusion queries (see GPUInfo.OcclusionQuery) and
	// OcclusionTest is set to true on the graphics object, then this method
	// will return the number of samples that passed the depth and stencil
	// testing phases the last time the object was drawn. If occlusion queries
	// are not supported then -1 will be returned.
	SampleCount() int
}

type NativeTexture interface {
	Destroyable
	Downloadable

	// ChosenFormat tells the texture format chosen by the device for storing
	// this texture on the graphics device. It may differ from the Texture's
	// Format field only if the graphics device does not support that format.
	ChosenFormat() TexFormat
}

type Object struct {
	// The native object of this graphics object. The device using this
	// graphics object will assign a value to this field once ownership of the
	// object has been passed back to the caller of Draw.
	NativeObject

	// Whether or not this object should be occlusion tested. See also the
	// SampleCount() method of NativeObject.
	OcclusionTest bool

	// The render state of this object.
	*State

	// The transformation of the object.
	*Transform

	// The shader program to be used during drawing the object.
	*Shader

	// A slice of meshes which make up the object. The order in which the
	// meshes appear in this slice also affects the order in which they are
	// sent to the graphics card.
	//
	// This is a slice specifically to allow device implementations to optimize
	// the number of draw calls that must occur to draw consecutively listed
	// meshes.
	Meshes []*Mesh

	// A slice of textures which are used to texture the meshes of this object.
	// The order in which the textures appear in this slice is also the order
	// in which they are sent to the graphics card.
	Textures []*Texture

	// CachedBounds represents the pre-calculated cached bounding box of this
	// object. Note that the bounds are only calculated once Object.Bounds() is
	// invoked.
	//
	// If you make changes to the vertices of any mesh associated with this
	// object, or if you add / remove meshes from this object, the bounds will
	// not reflect this automatically. Instead, you must clear the cached
	// bounds explicitly:
	//
	//  o.CachedBounds = nil
	//
	// And then simply invoke o.Bounds() again to calculate the bounds again.
	CachedBounds *lmath.Rect3
}

type Precision struct {
	// The precision in bits of each pixel in the color buffer, per color (e.g.
	// 8/8/8/8 would be 32bpp RGBA color, 8/8/8/0 would be 24bpp RGB color, and
	// so on).
	RedBits, GreenBits, BlueBits, AlphaBits uint8

	// The precision in bits of each pixel in the depth buffer (e.g. 8, 16, 24,
	// etc).
	DepthBits uint8

	// The precision in bits of each pixel in the stencil buffer (e.g. 8, 16,
	// 24, etc).
	StencilBits uint8

	// The number of samples available per pixel (e.g. the number of MSAA
	// samples).
	Samples int
}

type Primitive uint8

type RTTConfig struct {
	// Bounds is the target resolution of the canvas to render at.
	Bounds image.Rectangle

	// The number of samples to use for multisampling. It should be one of the
	// numbers listed in the GPUInfo.RTTFormats structure.
	Samples int

	// Color, Depth, and Stencil textures, each of these texture's Format
	// fields are explicitly ignored (see the format fields below). If any of
	// these textures are non-nil, the results of that buffer (e.g. the color
	// buffer) are stored into that texture.
	//
	// Specify nil for any you do not intend to use as a texture (e.g. if you
	// want a 16-bit depth buffer but do not intend to use it as a texture, you
	// should set Depth == nil and DepthFormat == Depth16).
	Color, Depth, Stencil *Texture

	// Color format to use for the color buffer, it should be one listed in the
	// GPUInfo.RTTFormats structure.
	ColorFormat TexFormat

	// Depth and Stencil formats to use for the depth and stencil buffers,
	// respectively. They should be ones listed in the GPUInfo.RTTFormats
	// structure.
	//
	// Combined depth and stencil formats can be used (e.g. by setting
	// both DepthFormat and StencilFormat to Depth24AndStencil8), they are
	// often faster and use less memory, but with the caveat that they cannot
	// be used as textures.
	DepthFormat, StencilFormat DSFormat
}

type RTTFormats struct {
	// Slice of sample counts available for multisampling.
	Samples []int

	// Slice of color buffer formats.
	ColorFormats []TexFormat

	// Slices of depth and stencil buffer formats.
	DepthFormats, StencilFormats []DSFormat
}

type Shader struct {
	// The native object of this shader. Once the shader is loaded (if no
	// compiler error occured) then this field will be initialized by the
	// device. Only device implementations should assign values to this field.
	NativeShader Destroyable

	// Weather or not this shader is currently loaded or not.
	Loaded bool

	// If true then when this shader is loaded the data sources of it will be
	// kept instead of being set to nil (which allows them to be garbage
	// collected).
	KeepDataOnLoad bool

	// The name of the shader, optional (used in the shader compilation error
	// log).
	Name string

	// GLSL represents the sources to the GLSL shader. Only OpenGL devices
	// support GLSL, so you can check for this:
	//
	//  if device.Info().GLSL != nil {
	//      // Device supports GLSL shaders.
	//  }
	//
	GLSL *GLSLSources

	// A map of names and values to use as inputs for the shader program while
	// rendering. Values must be of the following data types or else they will
	// be ignored:
	//
	//  bool
	//  float32
	//  []float32
	//  gfx.Vec3
	//  []gfx.Vec3
	//  gfx.Vec4
	//  []gfx.Vec4
	//  gfx.Mat4
	//  []gfx.Mat4
	//  gfx.Color
	//  []gfx.Color
	//  gfx.TexCoord
	//  []gfx.TexCoord
	//
	Inputs map[string]interface{}

	// The error log from compiling the shader program, if any. Only set once
	// the shader is loaded.
	Error []byte
}

type State struct {
	// A single alpha transparency mode describing how transparent parts of
	// of the object are to be drawn.
	//
	// Must be one of: NoAlpha, AlphaBlend, BinaryAlpha, AlphaToCoverage
	AlphaMode AlphaMode

	// Blend represents how blending between existing (source) and new
	// (destination) pixels in the color buffer occurs when AlphaMode ==
	// AlphaBlend.
	Blend BlendState

	// Whether or not red/green/blue/alpha should be written to the color
	// buffer or not when drawing the object.
	WriteRed, WriteGreen, WriteBlue, WriteAlpha bool

	// Whether or not dithering should be used when drawing the object.
	Dithering bool

	// DepthClamp when enabled effectively disables the near and far clipping
	// planes when drawing the object.
	DepthClamp bool

	// Whether or not depth testing and depth writing should be enabled when
	// drawing the object.
	DepthTest, DepthWrite bool

	// The comparison operator to use for depth testing against existing pixels
	// in the depth buffer.
	DepthCmp Cmp

	// Whether or not stencil testing should be enabled when drawing the
	// object.
	StencilTest bool

	// Whether or not (and how) face culling should occur when drawing the
	// object.
	//
	// Must be one of: BackFaceCulling, FrontFaceCulling, NoFaceCulling
	FaceCulling FaceCullMode

	// The stencil state for front and back facing pixels, respectively.
	StencilFront, StencilBack StencilState
}

type StencilOp uint8

type StencilState struct {
	// A mask that will be AND'd with each pixel to be written to the stencil
	// buffer, e.g. 0xFFFF would allow writing to the full range of every pixel
	// in the stencil buffer when drawing the object.
	WriteMask uint

	// A mask that will be AND'd with each pixel to be read/compared to the
	// existing value in the stencil buffer, e.g. 0xFFFF would disable the use
	// of the mask altogether.
	ReadMask uint

	// The reference value that will be used to compare existing values in the
	// stencil buffer against, e.g. if s.Reference == 2 and if s.Func ==
	// GreaterOrEqual, then any value below 2 would not be affected.
	Reference uint

	// Fail specifies what stencil operation should occur when the stencil test
	// fails.
	//
	// Any predefined StencilOp constant is accepted.
	Fail StencilOp

	// DepthFail specifies what stencil operation should occur when the stencil
	// test passes but the depth test fails.
	//
	// Any predefined StencilOp constant is accepted.
	DepthFail StencilOp

	// DepthPass specifies what stencil operation should occur when the stencil
	// test passes and the depth test passes.
	//
	// Any predefined StencilOp constant is accepted.
	DepthPass StencilOp

	// Cmp specifies the comparison operator to use when comparing stencil data
	// with existing data in the stencil buffer.
	//
	// Any predefined Cmp constant is accepted.
	Cmp Cmp
}

type TexCoord struct {
	U, V float32
}

type TexCoordSet struct {
	// The slice of texture coordinates for the set.
	Slice []TexCoord

	// Weather or not the texture coordinates of this set have changed since
	// the last time the mesh was loaded. If set to true the device should
	// take note and re-upload the data slice to the graphics hardware.
	Changed bool
}

type TexFilter uint8

type TexFormat uint8

type TexWrap uint8

type Texture struct {
	// The native object of this texture. Once the texture is loaded by a
	// device this field will be initialized by the device. Only device
	// implementations should assign values to this field.
	NativeTexture

	// Weather or not this texture is currently loaded or not. If Loaded is set
	// false on a already-loaded texture, it will cause the device to reload
	// the texture.
	Loaded bool

	// If true then when this texture is loaded the data image source of it
	// will be kept instead of being set to nil (which allows it to be garbage
	// collected).
	KeepDataOnLoad bool

	// Dynamic is a hint (it does not restrict how the texture may be used) to
	// the graphics device on how this texture might be used. If you intend to
	// update texture data often (i.e. it's not static) then set this to true.
	Dynamic bool

	// The bounds of the texture, in the case of a texture loaded from a image
	// this should be set to the image's bounds. In the case of rendering to a
	// texture this should be set to the desired canvas resolution.
	Bounds image.Rectangle

	// The source image of the texture, may be nil (i.e. in the case of render
	// to texture, unless downloaded).
	Source image.Image

	// The texture format to use for storing this texture on the GPU, which may
	// result in lossy conversions (e.g. RGB would lose the alpha channel, etc).
	//
	// If the format is not supported then the device may use an image format
	// that is similar and is supported (and the format chosen by the device
	// can be determined via NativeTexture's ChosenFormat method).
	Format TexFormat

	// The U and V wrap modes of this texture.
	WrapU, WrapV TexWrap

	// The color of the border when a wrap mode is set to BorderColor.
	BorderColor Color

	// The texture filtering used for minification and magnification of the
	// texture.
	MinFilter, MagFilter TexFilter
}

type Transform struct {
	// contains filtered or unexported fields
}

type Transformable interface {
	Transform() *Transform
}

type Vec3 struct {
	X, Y, Z float32
}

type Vec4 struct {
	X, Y, Z, W float32
}

type VertexAttrib struct {
	// The literal per-vertex data slice. It must be a slice whose length is
	// exactly the same as the mesh's Vertices slice (because it is literally
	// per-vertex data). The underlying type must be one of the following or
	// else the attribute may be ignored completely:
	//  []float32
	//  [][]float32
	//  []gfx.Vec3
	//  [][]gfx.Vec3
	//  []gfx.Vec4
	//  [][]gfx.Vec4
	//  []gfx.Mat4
	//  [][]gfx.Mat4
	//  []gfx.Color
	//  [][]gfx.Color
	//  []gfx.TexCoord
	//  [][]gfx.TexCoord
	Data interface{}

	// Weather or not the per-vertex data (see the Data field) has changed
	// since the last time the mesh was loaded. If set to true the device
	// should take note and re-upload the data slice to the device's memory.
	Changed bool
}