entity

type Entity struct {
	// Position of the entity.
	Position mgl32.Vec3

	// Rotation about the center. Note that this is a quaternion - a mathematical way of representing rotation.
	// Quaternions make some things easy, like having smooth rotations between different orientations, but
	// they aren't as intuitive as a simple Roll, Pitch, Yaw representation.
	//
	// If you don't want to deal with quaternions, just use the provided rotation related functions attached to the Entity struct:
	// SetRotation, ModifyRotationLocal, and ModifyRotationGlobal.
	//
	// When dealing with quaternions, there are a few basic things to know:
	// 1. Multiplying quaternions is like applying a rotation, and order matters.
	//    Q1.Mul(Q2) means start from the rotation of Q1, and apply the Q2 to it.
	// 2. You can convert roll, pitch, and yaw ("Euler Angles")  into a quaternion.
	//    quat := mgl32.AnglesToQuat(rot.X(), rot.Y(), rot.Z(), mgl32.XYZ)
	//    but converting back isn't built into mgl32. I believe the reason for this is there are multiple possible
	//    combinations of Euler angles that can all result in the same quaternion or overall orientation.
	// 3. A common situation is having an overall amount that you want to rotate per second, but you need to scale
	//    it down so only a little bit is done per frame. Do this using some form of quaternion interpolation.
	//    Slerp (Spherical Linear Interpolation) is quite common, but Nlerp (Normalized Linear Interpolation) is much faster
	//    and will likely give similar results.
	//    deltaRotation := mgl32.QuatSlerp(mgl32.QuatIdent(), rotationSpeedPerSecond, timeInSeconds)
	//
	//    There's also a function for this in the util package: util.ScaleQuatRotation(q mgl32.Quat, percent float32) mgl32.Quat
	//    Usage:
	//      rotationSpeed := mgl32.AnglesToQuat(0, 0, 2 * math.Pi, mgl32.XYZ) // Allow one full rotation per second.
	//      deltaTime := 0.016 																							  // Time passed in the last frame is very small.
	//      rotation := util.ScaleQuatRotation(rotationSpeed, deltaTime)		  // rotationSpeed * time = rotation
	//
	Rotation mgl32.Quat

	// Scale is how large the entity is in each dimension.
	// All meshes and collision boxes are expected to be initialized as unit cubes or unit squares centered at the origin
	// so scale can be used to compare them. This breaks if a mesh starts out as being larger/smaller since its scale
	// will need to be smaller/larger in order to draw it at the proper size. Any larger or smaller meshes should have their
	// meshes normalized to fit snugly in a unit cube as they are loaded.
	Scale mgl32.Vec3
}

type Target interface {
	GetPosition() mgl32.Vec3
}