Struct JobRVO Extends IJobParallelForBatched

float CalculateForwardClearance (

NativeSlice<int>	neighbours
MovementPlaneWrapper	movementPlane
float3	position
float	radius
float2	targetDir

)

Find the distance we can move towards our target without colliding with anything.

May become negative if we are currently colliding with something.

void Execute (

int	startIndex
int	batchSize

)

void ExecuteORCA (

int	startIndex
int	batchSize

)

void GenerateObstacleVOs (

int	agentIndex
NativeList<int>	adjacentObstacleIdsScratch
NativeArray<int2>	adjacentObstacleVerticesScratch
NativeArray<float>	segmentDistancesScratch
NativeArray<int>	sortedVerticesScratch
NativeArray<ORCALine>	orcaLines
NativeArray<int>	orcaLineToAgent
ref int	numLines
in MovementPlaneWrapper	movementPlane
float2	optimalVelocity

)

Generates ORCA half-planes for all obstacles near the agent.

For more details refer to the ORCA (Optimal Reciprocal Collision Avoidance) paper.

This function takes in several arrays which are just used for temporary data. This is to avoid the overhead of allocating the arrays once for every agent.

bool BiasDesiredVelocity (

UnsafeSpan<ORCALine>	lines
ref float2	desiredVelocity
ref float2	targetPointInVelocitySpace
float	maxBiasRadians

)

Bias towards the right side of agents.

Rotate desiredVelocity at most [value] number of radians. 1 radian ≈ 57° This breaks up symmetries.

The desired velocity will only be rotated if it is inside a velocity obstacle (VO). If it is inside one, it will not be rotated further than to the edge of it

The targetPointInVelocitySpace will be rotated by the same amount as the desired velocity

bool ClipBoundary (

NativeArray<ORCALine>	lines
int	lineIndex
float	radius
out float	tLeft
out float	tRight

)

bool ClipLine (

ORCALine	line
ORCALine	clipper
ref float	tLeft
ref float	tRight

)

Clip a line to the feasible region of the half-plane given by the clipper.

The clipped line is `line.point + line.direction*tLeft` to `line.point + line.direction*tRight`.

Returns false if the line is parallel to the clipper's border.

float ClosestPointOnSegment (

float2	a
float2	dir
float2	p
float	t0
float	t1

)

float2 ClosestSegmentSegmentPointNonIntersecting (

ORCALine	a
ORCALine	b
float	ta1
float	ta2
float	tb1
float	tb2

)

Closest point on segment a to segment b.

The segments are given by infinite lines and bounded by t values. p = line.point + line.dir*t.

It is assumed that the two segments do not intersect.

float DistanceInsideVOs (

UnsafeSpan<ORCALine>	lines
float2	velocity

)

Calculates how far inside the infeasible region of the ORCA half-planes the velocity is.

Returns 0 if the velocity is in the feasible region of all half-planes.

void DrawVO (

CommandBuilder	draw
float2	circleCenter
float	radius
float2	origin
Color	color

)

void InsertionSort<T,U> (

UnsafeSpan<T>	data
U	comparer

)

Sorts the array in place using insertion sort.

This is a stable sort.

Used only because Unity.Collections.NativeSortExtension.Sort seems to have some kind of code generation bug when using Burst 1.8.2, causing it to throw exceptions.

bool LinearProgram1D (

NativeArray<ORCALine>	lines
int	lineIndex
float	radius
float2	optimalVelocity
bool	directionOpt
ref float2	result

)

LinearProgram2Output LinearProgram2D (

NativeArray<ORCALine>	lines
int	numLines
float	radius
float2	optimalVelocity
bool	directionOpt

)

LinearProgram2Output LinearProgram2DCollapsedSegment (

NativeArray<ORCALine>	lines
int	numLines
int	startLine
float	radius
float2	currentResult
float2	optimalVelocityStart
float2	optimalVelocityDir
float	optimalTLeft
float	optimalTRight

)

Like LinearProgram2D, but the optimal velocity space is a segment instead of a point, however the current result has collapsed to a point.

LinearProgram2Output LinearProgram2DSegment (

NativeArray<ORCALine>	lines
int	numLines
float	radius
float2	optimalVelocityStart
float2	optimalVelocityDir
float	optimalTLeft
float	optimalTRight
float	optimalT

)

Like LinearProgram2D, but the optimal velocity space is a segment instead of a point.

void LinearProgram3D (

NativeArray<ORCALine>	lines	The half-planes of all obstacles and agents.
int	numLines	The number of half-planes in lines.
int	numFixedLines	The number of half-planes in lines which are fixed (0..numFixedLines). These will be treated as static obstacles which should be avoided at all costs.
int	beginLine	The index of the first half-plane in lines for which the previous optimization failed (see LinearProgram2Output.firstFailedLineIndex).
float	radius	Maximum possible speed. This represents a circular velocity obstacle.
ref float2	result	Input is best velocity as output by LinearProgram2D. Output is the new best velocity. The velocity with the smallest maximum penetration into the given half-planes.
NativeArray<ORCALine>	scratchBuffer	A buffer of length at least numLines to use for scratch space.

)

Finds the velocity with the smallest maximum penetration into the given half-planes.

Assumes there are no points in the feasible region of the given half-planes.

Runs a 3-dimensional linear program, but projected down to 2D. If there are no feasible regions outside all half-planes then we want to find the velocity for which the maximum penetration into infeasible regions is minimized. Conceptually we can solve this by taking our half-planes, and moving them outwards at a fixed speed until there is exactly 1 feasible point. We can formulate this in 3D space by thinking of the half-planes in 3D (velocity.x, velocity.y, penetration-depth) space, as sloped planes. Moving the planes outwards then corresponds to decreasing the z coordinate. In 3D space we want to find the point above all planes with the lowest z coordinate. We do this by going through each plane and testing if it is possible that this plane is the one with the maximum penetration. If so, we know that the point will lie on the portion of that plane bounded by the intersections with the other planes. We generate projected half-planes which represent the intersections with the other 3D planes, and then we run a new optimization to find the point which penetrates this half-plane the least.

float det (

float2	vector1
float2	vector2

)

Determinant of the 2x2 matrix defined by vector1 and vector2.

Alternatively, the Z component of the cross product of vector1 and vector2.

bool left (

float2	vector1
float2	vector2

)

True if vector2 is to the left of vector1.

bool leftOrColinear (

float2	vector1
float2	vector2

)

True if vector2 is to the left of vector1 or if they are colinear.

bool right (

float2	vector1
float2	vector2

)

True if vector2 is to the right of vector1.

bool rightOrColinear (

float2	vector1
float2	vector2

)

True if vector2 is to the right of vector1 or if they are colinear.

float2 rot90 (

float2

v

)

SimulatorBurst.AgentData agentData

bool allowBoundsChecks

float deltaTime

CommandBuilder draw

NavmeshEdges.NavmeshEdgeData navmeshEdgeData

SimulatorBurst.AgentOutputData output

float priorityMultiplier

float symmetryBreakingBias

SimulatorBurst.TemporaryAgentData temporaryAgentData

const int MaxObstacleCount = 50