load

type AnmData ¶

type AnmData struct {
	Movements []Movement // Indexes into the given frames.
	Blends    []byte     // Vertex blend indicies. Arranged as [][4]byte
	Weights   []byte     // Vertex blend weights.  Arranged as [][4]byte
	Joints    []int32    // Joint parent information for each joint.
	Frames    []*lin.M4  // Animation transforms: [NumFrames][NumJoints].
}

AnmData holds the data necessary to a. It is an intermediate data format that needs further processing by something like vu.Ent.MakeModel to bind the data to a GPU.

type ChrData ¶

type ChrData struct {
	Char       rune // Character.
	X, Y, W, H int  // Character bit size.
	Xo, Yo, Xa int  // Character offset.
}

ChrData holds UV texture mapping information for one character. Expected to be used as part of FntData.

type FntData ¶

type FntData struct {
	W, H  int       // Width and height
	Chars []ChrData // Character data.
}

FntData holds UV texture mapping information for a font. It is intended for populating rendered models of strings. This is an intermediate data format that needs further processing by something like a vu.Ent.MakeModel to bind the data to a GPU and associate it with a texture atlas containing the bitmapped font images.

func (d *FntData) Load(name string, l Locator) (err error)

type ImgData ¶

type ImgData struct {
	Img image.Image
}

ImgData uses standard images as the underlying data format for textures. The image height, width, and bytes in (N)RGBA format are:

width  := img.Bounds().Max.X - img.Bounds().Min.X
height := img.Bounds().Max.Y - img.Bounds().Min.Y
rgba, _ := img.(*image.(N)RGBA)

Note that golang NRGBA are images with an alpha channel, but without alpha pre-multiplication. RGBA are images originally without an alpha channel, but assigned an alpha of 1 when read in.

This is an intermediate data format that needs further processing by something like vu.Ent.MakeModel to bind the data to a GPU based texture.

func (d *ImgData) Load(name string, l Locator) (err error)

type Locator ¶

type Locator interface {
	Dir(ext, dir string) Locator // Map a file extension to a directory.
	Dispose()                    // Properly terminate asset loading

	// GetResource allows applications to include and find custom resources.
	//   name: specific resource identifier, like a file or full file path.
	//   dir : prepended to the name path like a directory.
	GetResource(name string) (file io.ReadCloser, err error)
}

Locator knows how to search disk based locations for files. Locator uses a built in knowledge of paths and file types. It uses a convention for locating file types in directories where the defaults can be overridden or added to using the Dir method.

func NewLocator() Locator

PNG               : "images"
WAV               : "audio"
OBJ, IQM, MTL     : "models"
FNT, VSH, FSH, TXT: "source"

type ModData ¶

type ModData struct {
	MshData          // Vertex based data.
	AnmData          // Animation data.
	TMap    []TexMap // Texture name and vertex mapping data.
}

ModData combines vertex data, animation data and some texture names for a complete animated model. It is an intermediate data format that needs further processing by something like vu.Ent.MakeModel to bind the data to a GPU.

func (d *ModData) Load(name string, l Locator) (err error)

type Movement ¶

type Movement struct {
	Name   string  // Name of the animation
	F0, Fn uint32  // First frame, number of frames.
	Rate   float32 // Frames per second.
}

Movement marks a number of frames as a particular animated move that affects frames from F0 to F0+FN. Expected to be used as part of AnmData.

type MshData ¶

type MshData struct {
	Name string    // Imported model name.
	V    []float32 // Vertex positions.    Arranged as [][3]float32
	N    []float32 // Vertex normals.      Arranged as [][3]float32
	T    []float32 // Texture coordinates. Arranged as [][2]float32
	X    []float32 // Vertex tangents.     Arranged as [][2]float32
	F    []uint16  // Triangle faces.      Arranged as [][3]uint16
}

MshData stores vertex data from .obj files. It is intended for populating rendered models. The V,F buffers are expected to have data. The N,T,X buffers are optional.

MshData is an intermediate data format that needs further processing by something like vu.Ent.MakeModel to bind the data to a GPU.

func (d *MshData) Load(name string, l Locator) (err error)

type MtlData ¶

type MtlData struct {
	KaR, KaG, KaB float32 // Ambient color.
	KdR, KdG, KdB float32 // Diffuse color.
	KsR, KsG, KsB float32 // Specular color.
	Ns            float32 // Specular exponent.
	Alpha         float32 // Transparency
}

MtlData holds color and alpha information. It is intended for populating rendered models and is often needed for as attributes for shaders with lighting.

MtlData is an intermediate data format that needs further processing by something like vu.Ent.MakeModel to bind the data to uniforms in a GPU shader.

func (d *MtlData) Load(name string, l Locator) (err error)

type ShdData ¶

type ShdData struct {
	Vsh SrcData // Vertex shader.
	Fsh SrcData // Fragment (pixel) shader.
}

ShdData includes both vertex and fragment shader program source. Each line is terminated by a linefeed so that it will compile on the GPU.

ShdData is an intermediate data format that needs further processing by something like vu.Ent.MakeModel to compile the shader program and bind it to a GPU.

func (d *ShdData) Load(name string, l Locator) (err error)

type SndAttributes ¶

type SndAttributes struct {
	Channels   uint16 // Number of audio channels.
	Frequency  uint32 // 8000, 44100, etc.
	DataSize   uint32 // Size of audio data.
	SampleBits uint16 // 8 bits = 8, 16 bits = 16, etc.
}

SndAttributes describe how sound data is interpreted and played.

type SndData ¶

type SndData struct {
	Data  []byte         // the sound data bytes.
	Attrs *SndAttributes // Attributes describing the sound data.
}

SndData consists of the actual audio data bytes along with sounds attributes that describe how the sound data is interpreted and played.

SndData is an intermediate data format that needs further processing by something like vu.Eng.AddSound and vu.Ent.PlaySound to associate the noise with a 3D location and bind it to an audio card.

func (d *SndData) Load(name string, l Locator) (err error)

type SrcData ¶

type SrcData []string

SrcData is a slice of linefeed terminated strings used to load text based files.

func Src(r io.Reader) (d SrcData, err error)

type TexMap ¶

type TexMap struct {
	Name   string // Name of the texture resource.
	F0, Fn uint32 // First triangle face index and number of faces.
}

TexMap allows a model to have multiple textures. The named texture resource affects triangle faces from F0 to F0+FN. Expected to be used as part of ModData.