core

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

type AlwaysPassCuller struct{}

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

type AudioSystem interface {
	// Start starts the audio system. This is where implementations should detect
	// hardware devices and initialize them.
	Start()

	// Step is called by the application runloop update.
	Step()

	// Stop is called by the application after its main loop returns. Implementations
	// should call their termination/cleanup logic here.
	Stop()
}

type BindDescriptorsCommand struct {
	Descriptors *Descriptors
}

type BindStateCommand struct {
	State *protos.State
}

type BindUniformBufferCommand struct {
	Name          string
	UniformBuffer UniformBuffer
}

type BoundsCallbackFn func(n *Node) *AABB

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

type CameraRenderFn func(*Camera, map[*protos.State][]*Node)

type CamerasByRenderOrder []*Camera

type ClearCommand struct {
	ClearMode  ClearMode
	ClearColor mgl32.Vec4
	ClearDepth float64
}

type ClearMode uint8

type ClientApplication interface {
	InputComponent() ClientApplicationInputComponent
	Stop()
	Done() bool
}

type ClientApplicationCommand interface {
	Run(ac ClientApplication)
}

type ClientApplicationInputComponent interface {
	Run() []ClientApplicationCommand
}

type CollisionShape interface {
	// AddChildShape adds a child collision shape to this shape.
	AddChildShape(childshape CollisionShape, position mgl64.Vec3, orientation mgl64.Quat)

	// AddVertex adds a single vertex. Used for convex hull shapes.
	AddVertex(mgl64.Vec3)
}

type Culler interface {
	// Run culls a scenegraph node. A scene and camera are provided for visibility/frustum checks.
	// If the policy dictates the node is to be drawn, then it should be added to the nodeBucket.
	Run(*Scene, *Camera, *Node)
}

type DebugCommand struct {
	Message string
}

type DefaultCuller struct{}

type DefaultLightExtractor struct{}

type DefaultPhysicsComponent struct{}

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

type DrawCommand struct {
	Mesh Mesh
}

type DrawIMGUICommand struct {
}

type DrawInstancedCommand struct {
	Mesh          Mesh
	InstanceCount int
	InstanceData  unsafe.Pointer
}

type Framebuffer interface {
	// SetColorAttachment sets the color attachment at the specified index.
	SetColorAttachment(index int, attachment Texture)

	// ColorAttachments returns the framebuffer color attachments.
	ColorAttachments() map[int]Texture

	// ColorAttachment returns the color attachment at the specified index.
	ColorAttachment(index int) Texture

	// SetDepthAttachment sets the depth attachment.
	SetDepthAttachment(attachment Texture)

	// DepthAttachment returns the framebuffer depth attachment
	DepthAttachment() Texture
}

type IMGUICommand struct {
	ElementCount int
	ClipRect     [4]float32
	TextureID    unsafe.Pointer
}

type IMGUICommandList struct {
	CmdBufferSize    int
	VertexBufferSize int
	IndexBufferSize  int
	VertexPointer    unsafe.Pointer
	IndexPointer     unsafe.Pointer
	Commands         []IMGUICommand
}

type IMGUIDrawData interface {
	CommandListCount() int
	GetCommandList(int) *IMGUICommandList
}

type IMGUISystem interface {
	// Start is called at application startup. This is where implementations should check
	// for fonts, create their textures, etc.
	Start()

	// Stop is called at application shutdown. Implementations will want to perform cleanup here.
	Stop()

	// StartFrame is called at the draw stage of the runloop.
	StartFrame(dt float64)

	// EndFrame is called at the end of the draw stage of the runloop.
	EndFrame()

	// Begin creates a new widget and returns whether it is visible.
	Begin(name string, flags WindowFlags) bool

	// End closes the current active widget.
	End()

	// DisplaySize returns the current display size.
	DisplaySize() mgl32.Vec2

	// SetDisplaySize sets the display size. This is called by the application on every
	// iteration of the runloop. Implementations should check this for window resizes.
	SetDisplaySize(mgl32.Vec2)

	// SetNextWindowPos is used to request a position for the next window that gets created.
	SetNextWindowPos(mgl32.Vec2)

	// SetNextWindowSize is used to request a size for the next window that gets created.
	SetNextWindowSize(mgl32.Vec2)

	// GetDrawData returns IMGUIDrawData which is used by the RenderSystem to present the UI on screen.
	GetDrawData() IMGUIDrawData

	// CollapsingHeader returns a widget with a collapsing header.
	CollapsingHeader(name string) bool

	//PlotHistogram draws a histogram on a widget using the passed name and values. minScale and maxScale set
	// the Y axis scale and size sets the widgets width and height.
	PlotHistogram(name string, values []float32, minScale, maxScale float32, size mgl32.Vec2)

	// Image draws a texture on a widget with the provided size.
	Image(texture Texture, size mgl32.Vec2)

	// Text displays a text box
	Text(data string)
}

type InputComponent interface {
	// Run returns commands from a given node to itself.
	Run(node *Node) []NodeCommand
}

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

type InputState struct {
	Mouse MouseState
	Keys  KeyState
}

type InstanceData struct {
	ModelMatrix               mgl32.Mat4
	ModelViewProjectionMatrix mgl32.Mat4
	Custom                    [4]mgl32.Vec4
}

type KeyState struct {
	Valid    bool
	Mods     map[glfw.Key]bool
	Active   map[glfw.Key]bool
	Released map[glfw.Key]bool
}

type Light struct {
	Block    LightBlock
	Shadower Shadower
}

type LightBlock struct {
	VPMatrix [maxCascades]mgl32.Mat4
	ZCuts    [maxCascades]mgl32.Vec4
	Position mgl32.Vec4
	Color    mgl32.Vec4
}

type LightExtractor interface {
	// Run extracts light from a node and adds it to lightBucket.
	Run(node *Node, lightBucket *[]*Light)
}

type Mesh interface {
	SetPrimitiveType(PrimitiveType)

	SetPositions(positions []float32)
	SetNormals(normals []float32)
	SetTextureCoordinates(coordinates []float32)
	SetIndices(indices []uint16)

	SetName(name string)
	Name() string
	Draw()
	DrawInstanced(int, unsafe.Pointer)

	Bounds() *AABB

	Lt(Mesh) bool
	Gt(Mesh) bool
}

type MouseButtonState struct {
	Valid  bool
	Active map[glfw.MouseButton]bool
	Action int
}

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

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

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

type MousePositionState struct {
	Valid bool
	X     float64
	Y     float64
	DistX float64
	DistY float64
}

type MouseScrollState struct {
	Valid bool
	X     float64
	Y     float64
}

type MouseState struct {
	Valid    bool
	Position MousePositionState
	Scroll   MouseScrollState
	Buttons  MouseButtonState
}

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

type NodeCommand interface {
	Run(node *Node)
}

type NodesByCameraDistanceNearToFar struct {
	Nodes   []*Node
	RefNode *Node
}

type NodesByMaterial []*Node

type NodesByName struct {
	Nodes []*Node
}

type PhysicsComponent interface {
	// Run is called on each node which should determine whether it should be added to the simulation step or not.
	Run(node *Node, nodeBucket *[]*Node)
}

type PhysicsSystem interface {
	// Start is called by the application at startup time. Implementations should perform bootstapping here.
	Start()

	// Stop is called by the application at shutdown time. Implementations should perform cleanup here.
	Stop()

	// Update is called at every cycle of the application runloop with a list of nodes and a time delta from the
	// previous iteration. Implementations will want to perform all their computation here.
	Update(dt float64, nodes []*Node)

	// SetGravity sets the global gravity vector. This is for testing purposes and will be removed.
	SetGravity(g mgl64.Vec3)

	// AddRigidBody adds a rigid body to the physics world.
	AddRigidBody(RigidBody)

	// RemoveRigidBody removed a rigid body from the physics world.
	RemoveRigidBody(RigidBody)

	// CreateRigidBody creates a new rigid body which can be attached to a scenegraph node.
	CreateRigidBody(mass float32, collisionShape CollisionShape) RigidBody

	// DeleteRigidBody deletes a rigid body
	DeleteRigidBody(RigidBody)

	// NewStaticPlaneShape returns a collision shape.
	NewStaticPlaneShape(normal mgl64.Vec3, constant float64) CollisionShape

	// NewSphereShape returns a collision shape.
	NewSphereShape(radius float64) CollisionShape

	// NewBoxShape returns a collision shape.
	NewBoxShape(mgl64.Vec3) CollisionShape

	// NewCapsuleShape returns a collision shape.
	NewCapsuleShape(radius float64, height float64) CollisionShape

	// NewConeShape returns a collision shape.
	NewConeShape(radius float64, height float64) CollisionShape

	// NewCylinderShape returns a collision shape.
	NewCylinderShape(radius float64, height float64) CollisionShape

	// NewCompoundSphereShape returns a collision shape.
	NewCompoundShape() CollisionShape

	// NewConvexHullShape returns a collision shape.
	NewConvexHullShape() CollisionShape

	// NewStaticTriangleMeshShape returns a collision shape.
	NewStaticTriangleMeshShape(Mesh) CollisionShape

	// DeleteShape deletes a collision shape.
	DeleteShape(CollisionShape)
}

type Platform uint8

type PrimitiveType uint8

type Program interface {
	Name() string
}

type ProjectionType uint8

type RenderCommand interface{}

type RenderSystem interface {
	// PrepareWindow initializes a new window
	PreMakeWindow()
	PostMakeWindow(cfg WindowConfig, window *glfw.Window)

	// NewMesh retuns a new mesh.
	NewMesh() Mesh

	// ProgramExtension exposes the resource extension of program definitions for the implementation.
	ProgramExtension() string

	// NewProgram creates a new program from a list of subprogram source files.
	NewProgram(name string, data []byte) Program

	// NewTexture creates a new texture from a byte buffer containing an image file, not raw bitmap.
	// This always generates RGBA, unsigned byte and will generate mipmaps levels from
	// smallest dimension, ie: 2048x1024 = 10 mipmap levels; log2(1024)
	// It also defaults to ClampEdge and mipmapped filtering.
	NewTextureFromImageData(r []byte, d TextureDescriptor) Texture

	// NewUniform creates a new empty uniform
	NewUniform() Uniform

	// NewUniformBuffer creates a new empty uniform buffer
	NewUniformBuffer() UniformBuffer

	// NewRawTexture creates a new texture and allocates storage for it
	NewTexture(descriptor TextureDescriptor, data []byte) Texture

	// NewFramebuffer returns a newly created framebuffer
	NewFramebuffer() Framebuffer

	// Dispatch runs a rendercommand
	Dispatch(RenderCommand)

	// CanBatch returns whether two nodes can be batched in the same drawcall
	CanBatch(a *Descriptors, b *Descriptors) bool

	// RenderLog returns a log of the render plan
	RenderLog() string
}

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

type ResourceSystem interface {
	// Model returns a byte array representing a model.
	Model(string) []byte

	// Texture returns a byte array representing a texture.
	Texture(string) []byte

	// Program returns a byte array representing a program.
	Program(string) []byte

	// State returns a byte array representing a raster state
	State(string) []byte

	// ProgramData returns a byte array representing program data.
	ProgramData(string) []byte
}

type RigidBody interface {
	// GetTransform returns the rigid body world transform.
	GetTransform() mgl64.Mat4

	// SetTransform sets the rigid body world transform.
	SetTransform(mgl64.Mat4)

	// ApplyImpulse applies `impulse` on the rigid body at its position `localPosition`.
	ApplyImpulse(impulse mgl64.Vec3, localPosition mgl64.Vec3)
}

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

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

type SetFramebufferCommand struct {
	Framebuffer Framebuffer
}

type SetViewportCommand struct {
	Viewport mgl32.Vec4
}

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

type Shadower interface {
	// Textures returns the shadow textures used by this shadower
	Textures() []Texture

	// Render calls the shadower render implementation by assing a light and a scene camera.
	Render(*Light, *Camera)
}

type Texture interface {
	Descriptor() TextureDescriptor

	Handle() unsafe.Pointer

	// Lt is used for sorting
	Lt(Texture) bool

	// Gt
	Gt(Texture) bool

	// SetFilter
	SetFilter(TextureFilter)

	// SetWrapMode
	SetWrapMode(TextureWrapMode)
}

type TextureComponentType int

type TextureDescriptor struct {
	Width         uint32
	Height        uint32
	Mipmaps       bool
	Target        TextureTarget
	Format        TextureFormat
	SizedFormat   TextureSizedFormat
	ComponentType TextureComponentType
	Filter        TextureFilter
	WrapMode      TextureWrapMode
}

type TextureFilter int

type TextureFormat int

type TextureSizedFormat int

type TextureTarget int

type TextureWrapMode int

type TimerHistogram struct {
	Values []float32
	Min    float32
	Max    float32
}

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

type Uniform interface {

	// Value returns the Uniform's value
	Value() interface{}

	// Set sets the Uniform's value
	Set(interface{})

	// Copy returns a copy of the Uniform
	Copy() Uniform
}

type UniformBuffer interface {
	Set(unsafe.Pointer, int)

	// Lt is used for sorting
	Lt(UniformBuffer) bool

	// Gt
	Gt(UniformBuffer) bool
}

type Updater interface {
	// Run updates a scenegraph node.
	Run(*Node)
}

type WindowConfig struct {
	Name              string
	Monitor           *glfw.Monitor
	Width, Height, Hz int
	Fullscreen        bool
	Vsync             int
}

type WindowFlags int32

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