res

type Axis[T rangeScalarType] struct {
	EnabledValue bool
	// should be sync callback function, when the callback finished, the real process finished
	EnableCb enableCallback
	/* These two callbacks can be sync or async callback function, but MoveAbsCb and MoveRelCb should be the same type.
	   If they are sync functions, AutoStartMove flag and AutoStopMove flag are prefered to be true,
	   which means the Runningxxx flags are automatically maintained.
	   If they are async functions, AutoStartMove flag and AutoStopMove flag are prefered to be false,
	   which means you need to maintain the Runningxxx flags by StartMove/StopMove manually.
	*/
	MoveAbsCb moveCallback[T]
	MoveRelCb moveCallback[T]

	// should be sync callback function, when the callback finished, the real process finished
	StopCb          func() error
	Running         bool
	RunningPositive bool
	RunningNegative bool
	// should be sync callback function, when the callback finished, the real process finished
	GoHomeCb           gohomeCallback
	GoHomeDone         bool
	Homing             bool
	MaxLimit, MinLimit bool
	AutoStartMove      bool
	AutoStopMove       bool
	// contains filtered or unexported fields
}

type DoubleAxis = IAxis[float64]

type FloatAxis = IAxis[float32]

type IAxis[T rangeScalarType] interface {
	IRangeScalar[T]
	Enabled() bool
	Enable(bool) error
	MoveAbsolute(pos T) error
	MoveRelative(inc T) error
	IsRunning() bool
	IsHoming() bool
	GoHome(bool) error
	MaxLimitTriggered() bool
	MinLimitTriggered() bool
	IsRunningPositive() bool
	IsRunningNegative() bool
	Stop() error
}

type IMultiAxesMachine interface {
	IObject
	IResProvider
	GetAxesCnt() int
	GetAxis(i int) IAxis[float64]
	GetAxesPosition() []float64
	SetAxesPosition([]float64) error
	GetAxesPositionScalar() IWritableScalar[[]float64]
	Stop() error

	GetBasePosition() Position
	SetBasePosition(p Position)
	GetBaseRotation() RotationMatrix
	SetBaseRotation(r RotationMatrix)

	GetBaseTransition() TransitionMatrix
	SetBaseTransition(t TransitionMatrix)

	GetEndPosition() Position
	GetEndRotation() RotationMatrix
	GetEndTransition() TransitionMatrix

	GetEndPositionScalar() IWritableScalar[Position]
	GetEndRotationScalar() IWritableScalar[RotationMatrix]
	GetEndTransitionScalar() IWritableScalar[TransitionMatrix]
}

type IObject interface {
	Name() string
	Description() string
	Type() string
}

type IRangeScalar[T rangeScalarType] interface {
	IObject
	GetPos() T
	GetMaxPos() T
	GetMinPos() T
}

type IResProvider interface {
	GetItem(string, string) any
	SetDelegate(d *ResDelegate) error
	RegisterUpdateResourceCallback(f updateScalarCallback) error
}

type IResStorage interface {
	AddRes(IObject) error
}

type IScalar[T ScalarType] interface {
	IObject
	GetValue() T
	AddWatchCallback(WatchCallback[T]) (int, error)
	RemoveWatchCallback(cbIndex int) error
}

type IScalarHelper[T ScalarType] interface {
	IScalar[T]
	UpdateValue(T)
}

type IWritableScalar[T ScalarType] interface {
	IScalar[T]
	SetValue(T) error
}

type IWritableScalarHelper[T ScalarType] interface {
	IWritableScalar[T]
	UpdateValue(T)
	SetWriteCallback(WriteCallback[T]) error
}

type IntAxis = IAxis[int]

type MultiAxesMachine struct {
	Object
	IResProvider
	Res *ResManager

	EndPosCalcuCb func([]float64) (RotationMatrix, Position)
	BaseTransMat  TransitionMatrix

	AxesPositioin IWritableScalarHelper[[]float64]
	EndPosition   IWritableScalarHelper[Position]
	EndRotation   IWritableScalarHelper[RotationMatrix]
	EndTransition IWritableScalarHelper[TransitionMatrix]

	StopCb func() error
	// contains filtered or unexported fields
}

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

type Position = *mat.VecDense

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

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

type RotationMatrix = *mat.Dense

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

type ScalarType interface{}

type TransitionMatrix = *mat.Dense

type ValueWrapper[T ScalarType] func(T) T

type WatchCallback[T ScalarType] func(self IScalar[T], cur, last T)

type WriteCallback[T ScalarType] func(self IWritableScalar[T], val T) error