173 lines
7.3 KiB
C#
173 lines
7.3 KiB
C#
using UnityEngine;
|
|
using UnityEngine.Profiling;
|
|
|
|
namespace Pathfinding.RVO {
|
|
using Pathfinding.Util;
|
|
using Pathfinding.Drawing;
|
|
|
|
/// <summary>
|
|
/// Unity front end for an RVO simulator.
|
|
/// Attached to any GameObject in a scene, scripts such as the RVOController will use the
|
|
/// simulator exposed by this class to handle their movement.
|
|
/// In pretty much all cases you should only have a single RVOSimulator in the scene.
|
|
///
|
|
/// You can have more than one of these, however most scripts which make use of the RVOSimulator
|
|
/// will use the <see cref="active"/> property which just returns the first simulator in the scene.
|
|
///
|
|
/// This is only a wrapper class for a Pathfinding.RVO.Simulator which simplifies exposing it
|
|
/// for a unity scene.
|
|
///
|
|
/// See: Pathfinding.RVO.Simulator
|
|
/// See: local-avoidance (view in online documentation for working links)
|
|
/// </summary>
|
|
[ExecuteInEditMode]
|
|
[AddComponentMenu("Pathfinding/Local Avoidance/RVO Simulator")]
|
|
[HelpURL("https://arongranberg.com/astar/documentation/stable/rvosimulator.html")]
|
|
public class RVOSimulator : VersionedMonoBehaviour {
|
|
/// <summary>First RVOSimulator in the scene (usually there is only one)</summary>
|
|
public static RVOSimulator active { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Desired FPS for rvo simulation.
|
|
/// It is usually not necessary to run a crowd simulation at a very high fps.
|
|
/// Usually 10-30 fps is enough, but it can be increased for better quality.
|
|
/// The rvo simulation will never run at a higher fps than the game
|
|
/// </summary>
|
|
[Tooltip("Desired FPS for rvo simulation. It is usually not necessary to run a crowd simulation at a very high fps.\n" +
|
|
"Usually 10-30 fps is enough, but can be increased for better quality.\n"+
|
|
"The rvo simulation will never run at a higher fps than the game")]
|
|
public int desiredSimulationFPS = 20;
|
|
|
|
/// <summary>
|
|
/// Number of RVO worker threads.
|
|
/// If set to None, no multithreading will be used.
|
|
/// Using multithreading can significantly improve performance by offloading work to other CPU cores.
|
|
///
|
|
/// Deprecated: The number of worker threads is now set by the unity job system.
|
|
/// </summary>
|
|
[Tooltip("Number of RVO worker threads. If set to None, no multithreading will be used.")]
|
|
[System.Obsolete("The number of worker threads is now set by the unity job system", true)]
|
|
public ThreadCount workerThreads = ThreadCount.Two;
|
|
|
|
/// <summary>
|
|
/// Calculate local avoidance in between frames.
|
|
/// If this is enabled and multithreading is used, the local avoidance calculations will continue to run
|
|
/// until the next frame instead of waiting for them to be done the same frame. This can increase the performance
|
|
/// but it can make the agents seem a little less responsive.
|
|
///
|
|
/// This will only be read at Awake.
|
|
/// See: Pathfinding.RVO.Simulator.DoubleBuffering
|
|
///
|
|
/// Deprecated: Double buffering has been removed
|
|
/// </summary>
|
|
[Tooltip("Calculate local avoidance in between frames.\nThis can increase jitter in the agents' movement so use it only if you really need the performance boost. " +
|
|
"It will also reduce the responsiveness of the agents to the commands you send to them.")]
|
|
[System.Obsolete("Double buffering has been removed")]
|
|
public bool doubleBuffering;
|
|
|
|
/// <summary>
|
|
/// Prevent agent overlap more aggressively.
|
|
/// This will it much harder for agents to overlap, even in crowded scenarios.
|
|
/// It is particularly noticable when running at a low simulation fps.
|
|
/// This does not influence agent avoidance when the agents are not overlapping.
|
|
///
|
|
/// Enabling this has a small performance penalty, usually not high enough to care about.
|
|
///
|
|
/// Disabling this may be beneficial if you want softer behaviour when larger groups of agents collide.
|
|
/// </summary>
|
|
public bool hardCollisions = true;
|
|
|
|
/// <summary>\copydoc Pathfinding::RVO::SimulatorBurst::SymmetryBreakingBias</summary>
|
|
[Tooltip("Bias agents to pass each other on the right side.\n" +
|
|
"If the desired velocity of an agent puts it on a collision course with another agent or an obstacle " +
|
|
"its desired velocity will be rotated this number of radians (1 radian is approximately 57°) to the right. " +
|
|
"This helps to break up symmetries and makes it possible to resolve some situations much faster.\n\n" +
|
|
"When many agents have the same goal this can however have the side effect that the group " +
|
|
"clustered around the target point may as a whole start to spin around the target point.")]
|
|
[Range(0, 0.2f)]
|
|
public float symmetryBreakingBias = 0.1f;
|
|
|
|
/// <summary>
|
|
/// Determines if the XY (2D) or XZ (3D) plane is used for movement.
|
|
/// For 2D games you would set this to XY and for 3D games you would usually set it to XZ.
|
|
/// </summary>
|
|
[Tooltip("Determines if the XY (2D) or XZ (3D) plane is used for movement")]
|
|
public MovementPlane movementPlane = MovementPlane.XZ;
|
|
|
|
/// <summary>
|
|
/// Allows the local avoidance system to take the edges of the navmesh into account.
|
|
///
|
|
/// This will make agents try to avoid moving into, and getting pushed into the borders of the navmesh.
|
|
///
|
|
/// This works best on navmesh/recast graphs, but can also be used on grid graphs.
|
|
///
|
|
/// Enabling this has a performance impact.
|
|
///
|
|
/// Note: For the <see cref="AIPath"/> movement script, this only has an effect if the <see cref="AIPath.constrainInsideGraph"/> field is enabled.
|
|
///
|
|
/// If you are writing your own movement script, you must call <see cref="RVOController.SetObstacleQuery"/> every frame for the navmesh obstacle detection to work.
|
|
/// </summary>
|
|
public bool useNavmeshAsObstacle = false;
|
|
public bool drawQuadtree;
|
|
|
|
/// <summary>Reference to the internal simulator</summary>
|
|
Pathfinding.RVO.SimulatorBurst simulatorBurst;
|
|
|
|
/// <summary>
|
|
/// Get the internal simulator.
|
|
/// Will never be null when the game is running
|
|
/// </summary>
|
|
public SimulatorBurst GetSimulator () {
|
|
if (simulatorBurst == null && Application.isPlaying) {
|
|
simulatorBurst = new Pathfinding.RVO.SimulatorBurst(movementPlane);
|
|
}
|
|
return simulatorBurst;
|
|
}
|
|
|
|
void OnEnable () {
|
|
if (active != null) {
|
|
if (active != this && Application.isPlaying) {
|
|
if (enabled) Debug.LogWarning("Another RVOSimulator component is already in the scene. More than one RVOSimulator component cannot be active at the same time. Disabling this one.", this);
|
|
enabled = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
active = this;
|
|
}
|
|
|
|
/// <summary>Update the simulation</summary>
|
|
void Update () {
|
|
if (!Application.isPlaying) return;
|
|
|
|
if (desiredSimulationFPS < 1) desiredSimulationFPS = 1;
|
|
|
|
var sim = GetSimulator();
|
|
sim.DesiredDeltaTime = 1.0f / desiredSimulationFPS;
|
|
sim.SymmetryBreakingBias = symmetryBreakingBias;
|
|
sim.HardCollisions = hardCollisions;
|
|
sim.drawQuadtree = drawQuadtree;
|
|
sim.UseNavmeshAsObstacle = useNavmeshAsObstacle;
|
|
#if !MODULE_ENTITIES
|
|
sim.Update(default, Time.deltaTime, true, Unity.Collections.Allocator.TempJob).Complete();
|
|
#endif
|
|
}
|
|
|
|
void OnDisable () {
|
|
if (active == this) {
|
|
active = null;
|
|
}
|
|
if (simulatorBurst != null) {
|
|
simulatorBurst.OnDestroy();
|
|
simulatorBurst = null;
|
|
}
|
|
}
|
|
|
|
// static Color ObstacleColor = new Color(255/255f, 60/255f, 15/255f, 1.0f);
|
|
public override void DrawGizmos () {
|
|
// Prevent interfering with scene view picking
|
|
//if (Event.current.type != EventType.Repaint) return;
|
|
}
|
|
}
|
|
}
|