public void MoveAgent(
float ahead = 0,
float right = 0,
float speed = 1,
float?fixedDeltaTime = null,
bool returnToStart = true,
bool disableRendering = true
)
{
if (ahead == 0 && right == 0)
{
throw new ArgumentException("Must specify ahead or right!");
}
Vector3 direction = new Vector3(x: right, y: 0, z: ahead);
float fixedDeltaTimeFloat = fixedDeltaTime.GetValueOrDefault(Time.fixedDeltaTime);
CollisionListener collisionListener = this.GetComponentInParent <CollisionListener>();
Vector3 directionWorld = transform.TransformDirection(direction);
Vector3 targetPosition = transform.position + directionWorld;
collisionListener.Reset();
IEnumerator move = ContinuousMovement.move(
controller: this,
collisionListener: collisionListener,
moveTransform: this.transform,
targetPosition: targetPosition,
fixedDeltaTime: fixedDeltaTimeFloat,
unitsPerSecond: speed,
returnToStartPropIfFailed: returnToStart,
localPosition: false
);
if (disableRendering)
{
unrollSimulatePhysics(
enumerator: move,
fixedDeltaTime: fixedDeltaTimeFloat
);
}
else
{
StartCoroutine(move);
}
}
public void RotateAgent(
float degrees,
float speed = 1.0f,
bool waitForFixedUpdate = false,
bool returnToStart = true,
bool disableRendering = true,
float fixedDeltaTime = 0.02f
)
{
CollisionListener collisionListener = this.GetComponentInParent <CollisionListener>();
collisionListener.Reset();
// this.transform.Rotate()
IEnumerator rotate = ContinuousMovement.rotate(
controller: this,
collisionListener: this.GetComponentInParent <CollisionListener>(),
moveTransform: this.transform,
targetRotation: this.transform.rotation * Quaternion.Euler(0.0f, degrees, 0.0f),
fixedDeltaTime: disableRendering ? fixedDeltaTime : Time.fixedDeltaTime,
radiansPerSecond: speed,
returnToStartPropIfFailed: returnToStart
);
if (disableRendering)
{
unrollSimulatePhysics(
enumerator: rotate,
fixedDeltaTime: fixedDeltaTime
);
}
else
{
StartCoroutine(rotate);
}
}
public void moveArmTarget(
PhysicsRemoteFPSAgentController controller,
Vector3 target,
float unitsPerSecond,
float fixedDeltaTime = 0.02f,
bool returnToStart = false,
string coordinateSpace = "arm",
bool restrictTargetPosition = false,
bool disableRendering = false
)
{
// clearing out colliders here since OnTriggerExit is not consistently called in Editor
collisionListener.Reset();
IK_Robot_Arm_Controller arm = this;
// Move arm based on hand space or arm origin space
// Vector3 targetWorldPos = handCameraSpace ? handCameraTransform.TransformPoint(target) : arm.transform.TransformPoint(target);
Vector3 targetWorldPos = Vector3.zero;
switch (coordinateSpace)
{
case "world":
// world space, can be used to move directly toward positions
// returned by sim objects
targetWorldPos = target;
break;
case "wrist":
// space relative to base of the wrist, where the camera is
targetWorldPos = handCameraTransform.TransformPoint(target);
break;
case "armBase":
// space relative to the root of the arm, joint 1
targetWorldPos = arm.transform.TransformPoint(target);
break;
default:
throw new ArgumentException("Invalid coordinateSpace: " + coordinateSpace);
}
// TODO Remove this after restrict movement is finalized
Vector3 targetShoulderSpace = (this.transform.InverseTransformPoint(targetWorldPos) - new Vector3(0, 0, originToShoulderLength));
#if UNITY_EDITOR
Debug.Log(
$"pos target {target} world {targetWorldPos} remaining {targetShoulderSpace.z}\n" +
$"magnitude {targetShoulderSpace.magnitude} extendedArmLength {extendedArmLength}"
);
#endif
if (restrictTargetPosition && !validArmTargetPosition(targetWorldPos))
{
targetShoulderSpace = (
this.transform.InverseTransformPoint(targetWorldPos)
- new Vector3(0, 0, originToShoulderLength)
);
throw new InvalidOperationException(
$"Invalid target: Position '{target}' in space '{coordinateSpace}' is behind shoulder."
);
}
Vector3 originalPos = armTarget.position;
Vector3 targetDirectionWorld = (targetWorldPos - originalPos).normalized;
IEnumerator moveCall = ContinuousMovement.move(
controller,
collisionListener,
armTarget,
targetWorldPos,
disableRendering ? fixedDeltaTime : Time.fixedDeltaTime,
unitsPerSecond,
returnToStart,
false
);
if (disableRendering)
{
controller.unrollSimulatePhysics(
moveCall,
fixedDeltaTime
);
}
else
{
StartCoroutine(
moveCall
);
}
}
