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 DebugTrace (

int	agentIndex
float2	prev
float2	current
int	stepIndex

)

float2 EvaluateGradient (

int	agentIndex
NativeSlice<VelocityObstacle>	vos
float2	p
out float	value
float2	desiredVelocity

)

Evaluate gradient and value of the cost function at velocity p.

void Execute (

int	startIndex
int	batchSize

)

void ExecuteORCA (

int	startIndex
int	batchSize

)

void ExecuteSampled (

int	startIndex
int	batchSize

)

int GenerateNeighbourAgentVOs (

int	agentIndex
NativeArray<VelocityObstacle>	velocityObstacles
NativeSlice<int>	neighbours

)

void GenerateObstacleVOs (

int	agentIndex
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.

float2 GradientDescent (

int	agentIndex
NativeSlice<VelocityObstacle>	vos
float2	sampleAround1
float2	sampleAround2
float2	desiredVelocity

)

float2 Trace (

int	agentIndex
NativeSlice<VelocityObstacle>	vos
float2	p
out float	score
float2	desiredVelocity
int	iterations
float	stepSize

)

Traces the vector field constructed out of the velocity obstacles.

Returns the position which gives the minimum score (approximately).

bool BiasDesiredVelocity (

NativeArray<ORCALine>	lines
int	numLines
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 BiasDesiredVelocity (

NativeSlice<VelocityObstacle>	vos
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.

bool ClipLineToCircle (

float2	point
float2	direction
float	radius
out float	tLeft
out float	tRight

)

Clips an infinite line to the intersection with a circle.

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

Returns false if there is no intersection.

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 (

NativeArray<ORCALine>	lines
int	numLines
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

)

Vector3 FromXZ (

float2

p

)

(x, 0, y)

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
int	numLines
int	numFixedLines
int	beginLine
float	radius
ref float2	result
NativeArray<ORCALine>	scratchBuffer

)

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.

Color Rainbow (

float

v

)

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 collisionStrength

Should be in the range [0,1].

float deltaTime

CommandBuilder draw

SimulatorBurst.ObstacleData obstacleData

SimulatorBurst.AgentOutputData output

float priorityMultiplier

float symmetryBreakingBias

SimulatorBurst.TemporaryAgentData temporaryAgentData

const float DesiredVelocityWeight = 0.1f

const int MaxObstacleCount = 50