data

type Glyphs struct {
	Name string // Unique id for a glyph set.
	// contains filtered or unexported fields
}

type Loader interface {

	// Load looks for the named resource on disk and returns a corresponding resource
	// data object. The loader will look for "name" with any of the supported file
	// types for the given resource.
	//
	// Load expects data to be a pointer to one of the resource data types.
	// If found the resource data is copied into the supplied data pointer,
	// otherwise the supplied data pointer is set to nil.
	Load(name string, data interface{})

	// Cache the given resource data so that any single resource only needs
	// to be loaded once. Cache expects data to be one of the valid resource data types
	// and to be uniquely named within its data type.
	Cache(data interface{})

	// Cached returns true if the named data resource has already been cached and ready
	// to use. Cached expects data to be one of the valid resource data types.
	Cached(name string, data interface{}) bool

	// Fetch retrieves a previously cached resource using the given name.
	// Fetch expects the resource data to be a pointer to one of the resource data types.
	// If found the resource data is copied into the supplied data pointer.
	// Otherwise the supplied data pointer is set to nil
	Fetch(name string, data interface{})

	// SetDir overrides the default directory location for the given data type.
	// SetDir expects data to be one of the valid resource data types.
	//
	// Note that all directories are expected to be relative to the
	// application location.
	SetDir(dir string, data interface{})

	// Dispose needs to be called to properly terminate and clean up loaded resources.
	Dispose()
}

type Material struct {
	Name string  // Unique matrial name.
	Kd   Rgb     // Diffuse colour of the material.
	Ka   Rgb     // Ambient colour of the material.
	Ks   Rgb     // Specular colour of the material.
	Tr   float32 // Transparency (alpha, dissolve) for the material.
}

type Mesh struct {
	Name string // Unique mesh name.

	// Vertices are points in 3D space.  Each vertex is specified with
	// (x, y, z, w) where
	//    x, y are  mandatory 2D minimum coordinates,
	//    z can be defaulted to 0 for a 2D vertex, and
	//    w can be defaulted to 1 for a constant depth.
	V []float32 // Arranged as [][4]float32

	// Normals for each vertex. Normals are specified as (x, y, z) where each
	// value is between 0.0 and 1.0. The slice length is expected to be the same
	// length as the vertex slice, and each normal is calculated to be the
	// normalized sum of the normals for each face that shares the vertex.
	N []float32 // Arranged as [][3]float32

	// Texture coordinates. Specifies how the texture data is aligned relative
	// to the fragment. There are two floats for each texture (u, v) where the
	// values are expected to be between 0.0 and 1.0. The texture data is loaded
	// separately from an image file.
	//
	// The texture corresponding to these texture coordinates is expected to be
	// available to the rendering layer at the same time as this mesh.
	T []float32 // Arranged as [][2]float32

	// Faces are used to index the vertex data into shapes. These are
	// expected to be triangles so 3 indices form one face. Each face value
	// refers to a single vertex.
	F []uint16 // Arranged as [][3]uint16

	// Vao is an vertex array object. It is a graphic card reference to the above
	// group of data.  The "*buf" variables are individual graphic card references
	// for the above data.
	Vao  uint32 // Vertex array references all buffers.
	Vbuf uint32 // Vertex buffer.
	Tbuf uint32 // Texture buffer.
	Nbuf uint32 // Normals buffer.
	Fbuf uint32 // Face index buffer.
}

type Rgb struct {
	R float32 // Red.
	G float32 // Green.
	B float32 // Blue.
}

type Shader struct {
	Name     string           // Unique name (file name) of the shader.
	Vsh      []string         // Vertex shader source.
	Fsh      []string         // Fragment shader source.
	Program  uint32           // Reference to the compiled vertex and fragment program.
	Uniforms map[string]int32 // Uniform data is required.
}

type Sound struct {
	Name       string // Unique sound name.
	AudioData  []byte // The raw audio data.
	Channels   uint16 // Number of audio channels.
	SampleBits uint16 // 8 bits = 8, 16 bits = 16, etc.
	Frequency  uint32 // 8000, 44100, etc.
	DataSize   uint32 // Size of audio data (total file size minus header size).

	// Buffer is the sound card buffer reference that the sound data is loaded
	// into. Sound buffers can be shared among many sound sources.
	Buffer uint32
}

type Texture struct {
	Name string      // Unique name of the texture.
	Img  image.Image // Texture data.
	Tid  uint32      // Graphics card texture identifier.
}