axe

type AnimConstant[T any] struct {
	Value T
}

type AnimValue[T any] interface {
	Get() T
}

type AssetSystem struct {
	asset.Assets
}

type Attr[V any] interface {
	// distance between this and value
	Distance(value V) float32
	// squared distance between this and value
	DistanceSq(value V) float32
	// distance between this and zero
	Length() float32
	// squared distance between this and zero
	LengthSq() float32
	// dot product between this and value
	Dot(value V) float32
	// the number of float components that make up this attribute
	Components() int
	// gets the float component at the given index
	GetComponent(index int) float32
	// out[index] = value
	SetComponent(index int, value float32, out *V)
	// out[all] = value
	SetComponents(value float32, out *V)
	// out = this
	Set(out *V)
	// out = this + value
	Add(addend V, out *V)
	// out = this + value * scale
	AddScaled(value V, scale float32, out *V)
	// out = this - value
	Sub(subtrahend V, out *V)
	// out = this * value
	Mul(factor V, out *V)
	// out = this / value
	Div(factor V, out *V)
	// out = this * scale
	Scale(scale float32, out *V)
	// out = (end - start) * delta + start
	Lerp(end V, delta float32, out *V)
}

type AudioAmbience struct {
	PlayChance           int
	Options              []AudioAmbienceOption
	Volume               float32
	MaxPlaysBeforeRepeat int
	TransitionTime       NumericRange[float32]
}

type AudioAmbienceOption struct {
	Data       *AudioData
	Chance     int
	PlayVolume NumericRange[float32]
	PlayLength NumericRange[float32]
}

type AudioAttenuation func(distance float32, volume float32) float32

type AudioData struct {
	Length    int
	Streaming bool
	BitRate   int
	Reader    io.ReadSeekCloser
}

type AudioEmitter struct {
	Source   AudioSource
	Pending  []AudioRequest
	Ambience *AudioAmbience
}

type AudioInstance struct {
	Name           string
	Flags          uint
	Data           *AudioData
	Position       SpaceCoord // optional for spatial sounds
	Direction      SpaceCoord // optional for directional sounds
	PositionVolume float32    // volume at position
	Speed          float32    // playback rate modifier
	StartTime      time.Time
	PauseTime      time.Time
	Settings       *AudioInstanceSettings // custom or shared
	// relative to current listener
	Distance       float32
	ListenerVolume float32
	LeftVolume     float32
	RightVolume    float32
}

type AudioInstanceSettings struct {
	DirectionSpread     float32 // optional for direction sounds, how big the noise cone is
	StartOnRequest      bool    // if we set the start time when sound playing is requested, or when it actually starts. this plays into if we seek to the position the audio should've been playing by the time it was ready
	Times               int     // -1=Infinite loop
	Attenuate           AudioAttenuation
	IsVirtual           bool
	OnVirtual           AudioVirtualOp
	VirtualOutroTime    time.Duration // how long we fade out when going virtual
	VirtualMinRemaining time.Duration // if we are going virtual and not stopping but have <= this left then we just stop
	Importance          float32       // scales the listener volume by this amount to calculate a priority
}

type AudioListener struct {
	Name          string
	Flags         uint
	Position      SpaceCoord
	Direction     SpaceCoord
	Ears          SpaceCoord // Camera position?
	EarsDirection SpaceCoord
	VolumeScale   float32
}

type AudioRequest struct {
	MaxWaitTime time.Duration
	Instance    AudioInstance
}

type AudioSettings struct {
	AudioUnloadTime   time.Duration // how long to wait before we unload unused audio
	MaxAudioInstances int           // user specified, otherwise determined by available APIs or trial & error
}

type AudioSource struct {
	Name                string
	Flags               uint
	Position            SpaceCoord
	Direction           SpaceCoord
	DirectionInner      float32
	DirectionOuter      float32
	DirectionOuterScale float32
	Instances           []AudioInstance
}

type AudioSystem interface {
	GameSystem

	Listeners() []AudioListener
	Instances() []AudioInstance
	Settings() map[string]AudioSettings
	Sources() []AudioSource
	EntitySystem() ecs.DataSystem[AudioEmitter]
}

type AudioVirtualOp string

type BehaviorOnLive interface {
	OnLive(e *ecs.Entity, ctx ecs.Context)
}

type BehaviorOnRemove interface {
	OnRemove(e *ecs.Entity, ctx ecs.Context)
}

type BehaviorOnStage interface {
	OnStage(e *ecs.Entity, ctx ecs.Context)
}

type BehaviorOnUpdate interface {
	Update(e *ecs.Entity, ctx ecs.Context)
}

type BehaviorSystem[B any] struct{}

type Bounds[A Attr[A]] struct {
	Min       A
	Max       A
	Thickness float32
}

type Bounds2f = Bounds[Vec2f]

type Camera[A Attr[A]] interface {
	GameSystem

	GetTransform() Trans[A]
	GetPlanes() []Plane[A]
	GetMatrix() Mat[A]
}

type Camera2d struct {
	Transform Trans2d
	Size      Vec2d
	Near      Scalarf
	Far       Scalarf

	Up     Vec2d
	Right  Vec2d
	Left   Vec2d
	Down   Vec2d
	Min    Vec2d
	Max    Vec2d
	Aspect Scalarf
	Planes [4]Plane2d
	Matrix Mat2d
}

type Camera3d struct {
	Transform Trans3d
	Size      Vec2d
	Near      Scalarf
	Far       Scalarf
	Fov       Scalarf

	Up       Vec3d
	Right    Vec3d
	Left     Vec3d
	Down     Vec3d
	Forward  Vec3d
	Backward Vec3d
	Min      Vec3d
	Max      Vec3d
	Aspect   Scalarf
	Planes   [6]Plane3d
	Matrix   Mat3d
}

type Circle = Round[Vec2f]

type Computed[T any] interface {
	Compute(current *T)
}

type DebugEvent struct {
	Id       int
	Name     string
	Parent   *DebugEvent
	Depth    int
	Children []*DebugEvent
	Sibling  *DebugEvent
}

type DebugGraph struct {
	Placement ui.Placement
	Database  *StatDatabase
	Set       *StatSet
}

type DebugLog struct {
	Severity int
	Message  string
	Data     any
}

type DebugProfiler struct{}

type DebugSnapshot struct {
	At      time.Time
	Elapsed time.Duration
}

type DebugSystem struct {
	Logs      []DebugLog
	Snapshots []DebugSnapshot
	Graphs    []DebugGraph
	Events    []DebugEvent
	Enabled   bool
}

type Dynamic[T any] interface {
	Get() T
}

type EventSystem struct {
}

type Face struct {
	Vertices []int
	Uvs      []int
	Normals  []int
}

type FieldOfView string

type FontBitmapFormat struct{}

type Game struct {
	Debug    DebugSystem
	Assets   AssetSystem
	Windows  WindowSystem
	Graphics GraphicsSystem
	Input    InputSystem
	Actions  input.ActionSets
	Audio    AudioSystem
	Events   EventSystem
	Stages   StageManager
	State    GameState
	Settings GameSettings
	Running  bool
}

type GameSettings struct {
	Name                 string
	EnableDebug          bool
	FixedUpdateFrequency time.Duration
	FixedDrawFrequency   time.Duration
	FirstStage           string
	JobGroups            int
	JobBudget            int
	Stages               []Stage
	Assets               []asset.Ref
	Windows              []StageWindow
	WorldName            string
	WorldSettings        ecs.WorldSettings
}

type GameState struct {
	StartTime   time.Time
	UpdateTimer Timer
	DrawTimer   Timer
}

type GameSystem interface {
	Init(game *Game) error
	Update(game *Game)
	Destroy()
}

type GraphicsSystem interface {
	GameSystem
}

type InputActionListener struct {
	Handler func(action *input.Action) bool
}

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

type InputEvents = input.SystemEvents

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

type InputSystem interface {
	GameSystem
	input.InputSystem
}

type Integer interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

type Light struct {
	Ambient       color.Color
	Diffuse       color.Color
	Specular      color.Color
	Position      Vec4f
	SpotDirection Vec4f
	SpotExponent  uint8
	SpotCutOff    uint8
	Attenuate     LightAttenuate
}

type LightAttenuate int

type Line[A Attr[A]] struct {
	Start A
	End   A
}

type Logic func(e *ecs.Entity, ctx ecs.Context)

type LogicSystem struct{}

type Mat[A Attr[A]] interface {
	Get() []float32
	Set(values []float32)
	Identity()
	Transform(v A) A
	Multiply(other Mat[A])
	Invert()
}

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

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

type Material struct {
	Name        string       // Material name
	Illum       int          // Illumination model
	Opacity     float32      // Opacity factor
	Refraction  float32      // Refraction factor
	Shininess   float32      // Shininess (specular exponent)
	Ambient     TextureColor // Ambient color reflectivity
	Diffuse     TextureColor // Diffuse color reflectivity
	Specular    TextureColor // Specular color reflectivity
	Emissive    TextureColor // Emissive color
	TextureBump string
}

type Materials map[string]Material

type Matrix[A Attr[A]] struct {
	// contains filtered or unexported fields
}

type Matrix2f = Matrix[Vec2f]

type Matrix3f = Matrix[Vec3f]

type Matrix4f = Matrix[Vec4f]

type Mesh struct {
	Ref asset.Ref
	// contains filtered or unexported fields
}

type MeshData struct {
	Name      string
	Vertices  [][3]float32
	Normals   [][3]float32
	Uvs       [][2]float32
	Groups    []MeshFaceGroup
	Materials string
}

type MeshFaceGroup struct {
	Material string
	Faces    []Face
}

type MtlFormat struct {
}

type NoAudioSystem struct{}

type NoGraphicsSystem struct{}

type NoInputSystem struct {
	input.EmptySystem
}

type NoWindowSystem struct{}

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64
}

type NumericRange[D Numeric] struct {
	Min D
	Max D
}

type ObjFormat struct {
}

type Path[T Attr[T]] interface {
	Set(out *T, delta float32)
	PointCount() int
	Point(index int) AnimValue[T]
	Flags() PathFlag
}

type PathDelta[T Attr[T]] struct {
	Deltas []float32
	Points []AnimValue[T]
}

type PathFlag int

type PathLinear[T Attr[T]] struct {
	Inner PathDelta[T]
}

type PathPoint[T Attr[T]] struct {
	Value AnimValue[T]
}

type Plane[A Attr[A]] interface {
	SetPointNormal(point A, normal A)
	SetPoints(points []A)
	Distance(point A) float32
	GetPoint() A
	GetNormal() A
	Sign(point A) PlaneSign
}

type Plane2d struct {
	A, B, C float32
}

type Plane3d struct {
	A, B, C, D float32
}

type PlaneSign int

type ProjectionOutside int

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

type Range[A Attr[A]] struct {
	Min A
	Max A
}

type RenderTarget interface {
	Size() geom.Vec2i
	Texture() *Texture
	Window() *Window
}

type Round[A Attr[A]] struct {
	Center A
	Radius float32
}

type Scalar[D Numeric] struct {
	Value D
}

type Scalarf = Scalar[float32]

type Scalari = Scalar[int]

type Scene[A Attr[A]] struct {
	Name   string
	Jobs   *job.JobRunner
	World  *World
	Space  Space[A, SpaceComponent[A]]
	Enable func(scene *Scene[A], game *Game)
	Load   func(scene *Scene[A], game *Game)
}

type Scene2f = Scene[Vec2f]

type Scene3f = Scene[Vec3f]

type Screen interface {
	Size() geom.Vec2i
	Position() geom.Vec2i
}

type Segment[A Attr[A]] struct {
	Start A
	End   A
}

type Shape[A Attr[A]] interface {
	Finite() bool
	Distance(point A) float32
	Normal(point A, out *A) bool
	Raytrace(point A, direction A) bool
	Bounds(bounds *Bounds[A]) bool
	Round(round *Round[A]) bool
	PlaneSign(plane Plane[A]) PlaneSign
	Transform(shapeTransform Trans[A]) Shape[A]
}

type Space[A Attr[A], E any] interface {
	GameSystem

	Collisions(flags util.Match[SpaceFlags], callback SpaceCollisionCallback[E])
	Intersects(query SpaceQuery[A], callback SpaceSearchCallback[A, E]) int
	Contains(query SpaceQuery[A], callback SpaceSearchCallback[A, E]) int
	Raytrace(query SpaceQuery[A], callback SpaceSearchCallback[A, E]) int
	KNN(query SpaceQuery[A], nearest []SpaceNearest[E], nearestCount *int)
}

type SpaceCollisionCallback[E any] func(subject E, otherSubject E, overlap float32, index int, second bool)

type SpaceComponent[A Attr[A]] struct {
	Shape          Shape[A]
	Offset         A
	WorldTransform *Matrix[A]
	Flags          SpaceFlags
	Static         bool
	Inert          bool
}

type SpaceCoord interface {
	To2d() (x, y float32)
	To3d() (x, y, z float32)
}

type SpaceFlags uint64

type SpaceNearest[E any] struct {
	Entity   E
	Distance float32
}

type SpaceQuery[A Attr[A]] struct {
	Point   A
	End     A
	Shape   Shape[A]
	Maximum int
	Flags   util.Match[SpaceFlags]
}

type SpaceSearchCallback[A Attr[A], E any] func(entity E, overlap float32, index int, query SpaceQuery[A]) bool

type Sphere = Round[Vec3f]

type Stage struct {
	Name    string
	Assets  []asset.Ref
	Windows []StageWindow
	Scenes2 []Scene2f
	Scenes3 []Scene3f
	Views2  []View2f
	Views3  []View3f
	Actions input.ActionSets
	// contains filtered or unexported fields
}

type StageManager struct {
	Stages  map[string]*Stage
	Current *Stage
	Next    *Stage
	// contains filtered or unexported fields
}

type StageManagerEvents struct {
	StageStarting func(current *Stage)
	StageStarted  func(current *Stage)
	StageExiting  func(current *Stage, next *Stage)
	StageExited   func(previous *Stage, current *Stage)
}

type StageWindow struct {
	Name       string
	Title      string
	Placement  ui.Placement
	ClearColor color.Color
	Mode       WindowMode
	Screen     int
}

type StatDatabase struct {
	Name    string
	Updated time.Time
	Visible bool
	Event   *DebugEvent
	Enabled bool
	Sets    []StatSet
}

type StatPoint struct {
	Total int
	Sum   float64
	Min   float64
	Max   float64
}

type StatSet struct {
	Index        int
	Description  string
	Interval     time.Duration
	PointerTime  time.Time
	PointerIndex int
	Points       []StatPoint
}

type Tag string

type Texture interface {
	Asset() *asset.Asset
	Width() int
	Height() int
}

type TextureColor struct {
	Texture string
	Color   [3]float32
}

type TextureCoord struct {
	U float32
	V float32
}

type TextureFilter int

type TextureSettings struct {
	Min    TextureFilter
	Max    TextureFilter
	MipMap *TextureFilter
	WrapX  TextureWrap
	WrapY  TextureWrap
}

type TextureWrap int

type Tile struct {
	Texture Texture
	Name    string
	Coord0  TextureCoord
	Coord1  TextureCoord
}

type Tiles []Tile

type Time struct {
	Name        string
	DayDuration time.Duration
	Enabled     bool
	Scale       float32
	DateTime    time.Time
	Elapsed     time.Duration
	StartTime   time.Time
	// contains filtered or unexported fields
}

type TimeType uint8

type Timer struct {
	LastTick  time.Time
	Current   time.Time
	Elapsed   time.Duration
	Frequency time.Duration
	Ticks     int64
}

type Trans[A Attr[A]] interface {
	GetScale() A
	GetPosition() A
	ToMatrix(m []float32)
	Transform(v A) A
	TransformVector(v A) A
}

type Trans2d struct {
	Scale    Vec2d
	Position Vec2d
	Rotation Vec2d
}

type Trans3d struct {
	Scale    Vec3d
	Position Vec3d
	Rotation Quat
}

type Transform[A Attr[A]] struct {
	Tree ecs.Tree
	// contains filtered or unexported fields
}

type Transform2f = Transform[Vec2f]

type Transform3f = Transform[Vec3f]

type Transform4f = Transform[Vec4f]

type TransformCreate[A Attr[A]] struct {
	Position A
	Rotation A
	Scale    A
}

type TransformCreate2f = TransformCreate[Vec2f]

type TransformCreate3f = TransformCreate[Vec3f]

type TransformCreate4f = TransformCreate[Vec4f]

type TransformSystem[A Attr[A]] struct{}

type Tween[T Attr[T]] struct {
	Start AnimValue[T]
	End   AnimValue[T]
}

type UserInterface struct {
	*ui.UI
}

type UserInterfaceSystem struct{}

type Vec2[D Numeric] struct {
	X D
	Y D
}

type Vec2d = Vec2[float32]

type Vec2f = Vec2[float32]

type Vec2i = Vec2[int]

type Vec3[D Numeric] struct {
	X D
	Y D
	Z D
}