fizzle

type Camera interface {
	GetViewMatrix() mgl.Mat4
	GetPosition() mgl.Vec3
}

type Material struct {
	// Shader is the program used to render this material; This can be overridden
	// by using a DrawWithShader* function so that this material's shader doesn't
	// get used.
	Shader *RenderShader

	// DiffuseTex is the diffuse texture for the material.
	DiffuseTex graphics.Texture

	// NormalsTex is the normal map texture for the material.
	NormalsTex graphics.Texture

	// SpecularTex is the spcular map texture for the material.
	SpecularTex graphics.Texture

	// CustomTex is an array of textures that can be used for specific purposes
	// by client code that are not covered by other textures specified in this
	// structure.
	CustomTex [MaxCustomTextures]graphics.Texture

	// DiffuseColor is the material color for the renderable. This is
	// displayed outright by the shader or often blended with the
	// diffuse texture.
	DiffuseColor mgl.Vec4

	// SpecularColor is the material specular color for the renderable
	// and is used to control the color of the specular highlight.
	//
	// It can be thought of the topcoat layer color to the DiffuseColor's
	// base paint layer color.
	SpecularColor mgl.Vec4

	// Shininess is the specular coefficient used to control the tightness
	// of the specular highlight. It represents the power the specular factor will
	// be raised to -- therefore values between (0.0 - 1.0) will yield different
	// results than values >= 1.0.
	Shininess float32
}

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

type PreLinkBinder func(p graphics.Program)

type Rectangle3D struct {
	// Bottom defines the bottom corner opposite of Top.
	Bottom mgl.Vec3

	// TOp defines the top corner opposite of Bottom.
	Top mgl.Vec3
}

type RenderShader struct {
	// Prog is the OpenGL program associated with the RenderShader.
	Prog graphics.Program
	// contains filtered or unexported fields
}

type Renderable struct {
	// FaceCount specifies how many elements to draw when rendered.
	FaceCount uint32

	// Scale is the scaling vector for the Renderable used to modify
	// the size of the object.
	Scale mgl.Vec3

	// Location is the world-space location of Renderable.
	Location mgl.Vec3

	// Rotation is the world-space rotation quaternion of the Renderable, which is
	// different than LocalRotation and the pivot is {0,0,0} in world-space.
	Rotation mgl.Quat

	// LocalRotation is the local rotation quaternion for the Renderable, which is
	// different than the Rotation property and pivots around the model's origin.
	LocalRotation mgl.Quat

	// AnimationTime keeps track of the time value to use for the animation
	// currently applied (if any) to the Renderable.
	AnimationTime float32

	// BoundingRect is the unscaled, unrotated bounding rectangle for the renderable.
	BoundingRect Rectangle3D

	// IsVisible should be set to true if the object is to be rendered.
	IsVisible bool

	// IsGroup should be set to true if the renderable should only render its children objects
	// and that this Renderable itself should not be drawn.
	IsGroup bool

	// Core is the RenderableCore object that contains the renderable data that can
	// be shadered between multiple Renderable objects if needed.
	Core *RenderableCore

	// Material is the material for the object that will controll visible properties
	// used during rendering.
	Material *Material

	// Parent can be set to a Renderable that should be considered this Renderable's
	// 'Parent' which will make some properties relative to this parent object (e.g.
	// Location).
	Parent *Renderable

	// Children is a slice of Renderables that are the Renderable's children objects
	// that should be drawn with this renderable.
	Children []*Renderable
}

type RenderableCore struct {
	// Skeleton is the animatable skeleton object for the renderable.
	Skeleton *Skeleton

	// Vao is the OpenGL vertex array object for the renderable.
	Vao uint32

	// VaoInitialized indicates whether or not the Vao has been bound yet.
	VaoInitialized bool

	// VertVBO indicates the VBO that contains the vertex data.
	VertVBO graphics.Buffer

	// UvVBO indicates the VBO that contains the UV data.
	UvVBO graphics.Buffer

	// NormsVBO indicates the VBO that contains the normal vector data.
	NormsVBO graphics.Buffer

	// TangentsVBO indicates the VBO that contains the tangent vector data.
	TangentsVBO graphics.Buffer

	// ElementsVBO indicates the VBO that defines the element indices data.
	ElementsVBO graphics.Buffer

	// BoneFidsVBO indicates the VBO that defines what bones affect a given vertex.
	// These are passed to the shader as floats due to better compatability with GLSL.
	BoneFidsVBO graphics.Buffer

	// BoneWeightsVBO indicates the VBO that defines how strong a bone affects a given vertex.
	BoneWeightsVBO graphics.Buffer

	// ComboVBO1 is a user-customizable VBO object to be bound to the RenderShader.
	ComboVBO1 graphics.Buffer

	// ComboVBO2 is a user-customizable VBO object to be bound to the RenderShader.
	ComboVBO2 graphics.Buffer

	// VBOStride should be set to the total number of bytes that exist in a VBO for
	// a single object.
	//
	// This is set to non-zero when members like VertVBO, UvVBO,
	// NormsVBO, etc... are set tot the same VBO object but the data is interleaved.
	// When this is the case, the corresponding Offset members (e.g. VertVBOOffset)
	// should be set as well.
	VBOStride int32

	// VertVBOOffset is the offset in bytes from the start of a vertex definition needed
	// to read the vertex information.
	VertVBOOffset int

	// UvVBOOffset is the offset in bytes from the start of a vertex definition needed
	// to read the UV information.
	UvVBOOffset int

	// NormsVBOOffset is the offset in bytes from the start of a vertex definition needed
	// to read the normal vector information.
	NormsVBOOffset int

	// TangentsVBOOffset is the offset in bytes from the start of a vertex definition needed
	// to read the tangent vector information.
	TangentsVBOOffset int

	// BoneFidsVBOOffset is the offset in bytes from the start of a vertex definition needed
	// to read the bone float id information.
	BoneFidsVBOOffset int

	// BoneWeightsVBOOffset is the offset in bytes from the start of a vertex definition needed
	// to read the bone weighting information.
	BoneWeightsVBOOffset int

	// ComboVBO1Offset is the offset in bytes from the start of a vertex definition needed
	// to read the customizable information.
	ComboVBO1Offset int

	// ComboVBO2Offset is the offset in bytes from the start of a vertex definition needed
	// to read the customizable information.
	ComboVBO2Offset int

	// IsDestroyed should be set to true if the Renderable has been Destroy()'d.
	IsDestroyed bool
}

type RenderableMapF func(r *Renderable)

type Skeleton struct {
	// Bones is a slice of Bone objects defined for the mesh. This
	// will not be modified by the Skeleton methods and can be shared
	// between many instances of Skeleton.
	Bones []gombz.Bone

	// Animations is a slice of Animation objects that are compatible
	// with the Bones of the Skeleton.
	Animations []gombz.Animation

	// PoseTransforms are the final updated matrices for each bone
	// that represents it current position, scale and rotation in the pose.
	// This is the matrix stack that can get passed to OpenGL to transform vertices.
	PoseTransforms []mgl.Mat4
	// contains filtered or unexported fields
}

type TextureArray struct {
	// TextureIndexes is a map between the texture name to an index in the texture array object.
	TextureIndexes TextureArrayIndexes

	// Texture is the OpenGL texture object for all the loaded textures.
	Texture graphics.Texture
}

type TextureArrayIndexes map[string]int32

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

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