render

type JobTimingInfo struct {
	// Time elapsed while running the RenderJob func.
	RunTime time.Duration
	// Time elapsed between when a RenderJob was Queue'd on a
	// RenderQueueInterface and when the RenderJob func started.
	QueueTime time.Duration
}

type JobTimingListener struct {
	// NOTE: this notification runs on the render thread that ran the slow job.
	// Care should be taken not to make a bad situation worse!
	//
	// Called after a render job took longer than Threshold. The actual time
	// taken and the job's source attribution is also given.
	OnNotify func(*JobTimingInfo, string)

	// Only jobs that took Threshold or longer will trigger a call to OnNotify.
	// A job's total time is its RunTime plus its QueueTime.
	Threshold time.Duration
}

type Matrix = mathgl.Mat4

type MatrixMode int32

type RenderJob func(RenderQueueState)

type RenderQueueInterface interface {
	// The given callback will be invoked when queued jobs panic over an error
	// value. Note that such panics do _not_ cause the Queue to enter a 'defunct'
	// state; other jobs can still be queued and run.
	AddErrorCallback(func(RenderQueueInterface, error))

	// Eventually runs the given closure on a thread dedicated to OpenGL
	// operations. Jobs are run sequentially in the order queued. Each job is
	// passed a reference to data that must only be used on this
	// RenderQueueInterface's render thread. Callers may assume that the
	// RenderQueueState instance passed to each RenderJob is the same object
	// per-queue. Caveat: if the queue is in a 'defunct' state, calls to Queue()
	// will succeed but the jobs may not run.
	Queue(f RenderJob)

	// Blocks until all Queue'd jobs have completed. Note that, if other
	// goroutines are queueing jobs, this will block waiting for them as well!
	// If the queue enters a 'defunct' state (by calling StopProcessing or if the
	// underlying goroutine exits), current and subsequent calls to Purge() will
	// panic with a 'render.QueueShutdownError'.
	Purge()

	// StartProcessing() needs to be called exactly once per queue in order to
	// start running jobs. Queue()ing is allowed before processing has started.
	// Purge()ing is allowed before processing has started with the caveat that
	// even an empty queue will block Purge()ers from continuing until
	// StartProcessing() _is_ called.
	StartProcessing()

	// StopProcessing() can be called to stop processing jobs on the render
	// queue. It can be called before or after StartProcessing(). It will not
	// interrupt a running job but will pre-empt any other scheduled work. Any
	// subsequent or currently blocked calls to Purge() will panic with a
	// 'render.QueueShutdownError'. Calling StopProcessing() on a defunct queue
	// is a no-op.
	StopProcessing()

	// Returns true iff the queue is in a 'defunct' state.
	IsDefunct() bool

	// For debugability, polls the queue's current Purging/NotPurging status.
	IsPurging() bool
}

type RenderQueueState interface {
	Context() context.Context
	Shaders() *ShaderBank
}

type RenderQueueWithLoggerInterface interface {
	RenderQueueInterface
	SetLogger(glog.Logger)
}

type ShaderBank struct {
	ShaderProgs map[string]gl.Program
}

type Showmat mathgl.Mat4