/// <inheritdoc/>
public override ISensor[] CreateSensors()
{
DetectableGameObject.ClearCache();
ValidateGameObjectSettings();
if (m_GameObjectSettingsMeta.DetectableTags.Count > 0)
{
// Unlike GridSensorComponentBase, this component creates its own GridBuffer.
// We use a ColorGridBuffer in order to support PNG compression.
// GridShape is set by the 2D and 3D subcomponents prior to creating the buffer.
GridBuffer = new ColorGridBuffer(GridShape);
var sensors = base.CreateSensors();
if (Application.isPlaying)
{
// TODO It should be clearer which sensor features are enabled
// in editor vs play mode. Detector/Encoder code is supposed to
// be runtime only.
m_GridSensor.EnableAutoDetection(CreateDetector(), CreateEncoder());
}
return(sensors);
}
throw new UnityAgentsException("No detectable tags found! " +
"Add a detectable gameobject to the inspector settings.");
}
public override void Reset()
{
if (m_ClearCacheOnReset)
{
DetectableGameObject.ClearCache();
}
}
protected void ParseColliders(
int numFound,
DetectionConstraint constraint,
Matrix4x4 worldToLocalMatrix)
{
Vector3 sensorPos = m_Transform.position;
for (int i = 0; i < numFound; i++)
{
if (m_Settings.IsDetectableTag(
m_ColliderBuffer[i].tag,
out PointDetectionType type))
{
var detectable = DetectableGameObject.GetCached(m_ColliderBuffer[i]);
// Need to filter out compound collider duplicate results,
// as each collider is a key in DetectableGameObject's cache.
// We also ignore the sensor owner if there is a
// DetectableGameObject parent to the sensor.
if (detectable != m_Owner && !Result.Contains(detectable))
{
m_NormPoints.Clear();
m_WorldPoints.Clear();
switch (type)
{
case PointDetectionType.Position:
m_WorldPoints.Add(detectable.GetWorldPosition());
break;
case PointDetectionType.ClosestPoint:
m_WorldPoints.Add(detectable.GetClosestWorldPoint(sensorPos));
break;
case PointDetectionType.Shape:
float normDistance = constraint.GetNormalizedDistance(
worldToLocalMatrix.MultiplyPoint3x4(
detectable.GetClosestWorldPoint(sensorPos)));
m_WorldPoints.AddRange(
detectable.GetShapeWorldPoints(normDistance));
break;
}
for (int j = 0, c = m_WorldPoints.Count; j < c; j++)
{
if (constraint.ContainsPoint(
worldToLocalMatrix.MultiplyPoint3x4(m_WorldPoints[j]),
out Vector3 normPoint))
{
m_NormPoints.Add(normPoint);
}
}
if (m_NormPoints.Count > 0)
{
Result.Add(detectable, m_NormPoints);
}
}
}
}
}
/// <summary>
/// Invoked on sensor reset at the end of each episode.
/// </summary>
public void OnSensorReset()
{
if (m_ClearCacheOnReset)
{
DetectableGameObject.ClearCache();
}
}
protected void ParseColliders(int n, Constraint constraint, Matrix4x4 worldToLocalMatrix)
{
Vector3 sensorPos = m_Transform.position;
for (int i = 0; i < n; i++)
{
if (m_Settings.IsDetectableTag(m_Buffer[i].tag, out ColliderDetectionType type))
{
var detectable = DetectableGameObject.GetCached(m_Buffer[i]);
// Need to filter out compound collider duplicate results,
// as each collider is a key in DetectableGameObject's cache.
// NOTE
// We also skip the sensor owner if there's a DetectableGameObject
// parent to the sensor.
// Although the owner could be excluded by setting the minimum detection
// distance large enough for 3D, it's better to avoid checking the
// owner's points at every step in the first place.
if (detectable != m_Owner && !Result.Contains(detectable))
{
m_TmpNormPoints.Clear();
m_TmpWorldPoints.Clear();
switch (type)
{
case ColliderDetectionType.Position:
m_TmpWorldPoints.Add(detectable.GetPosition());
break;
case ColliderDetectionType.ClosestPoint:
m_TmpWorldPoints.Add(detectable.GetClosestPoint(sensorPos));
break;
case ColliderDetectionType.Shape:
m_TmpWorldPoints.AddRange(detectable.GetShapePoints(
constraint.NormalizeDistance(
worldToLocalMatrix.MultiplyPoint3x4(
detectable.GetPosition()))));
break;
}
for (int j = 0, c = m_TmpWorldPoints.Count; j < c; j++)
{
if (constraint.ContainsPoint(
worldToLocalMatrix.MultiplyPoint3x4(m_TmpWorldPoints[j]),
out Vector3 normalized))
{
m_TmpNormPoints.Add(normalized);
}
}
if (m_TmpNormPoints.Count > 0)
{
Result.Add(detectable, m_TmpNormPoints);
}
}
}
}
}
= new Dictionary <Collider, DetectableGameObject>(); // capacity?
private static void AddToCache(Collider cld, DetectableGameObject obj)
{
if (!s_SharedCache.ContainsKey(cld))
{
s_SharedCache.Add(cld, obj);
}
else
{
Debug.LogWarning("Collider already added to cache " + cld);
}
}
private void TryAddDetectableObject()
{
if (m_TmpObjectToAdd != null)
{
if (m_GameObjectSettingsMeta.TryAddDetectableObject(
m_GameObjectSettingsList, m_TmpObjectToAdd, DetectorSpaceType))
{
ValidateGameObjectSettings();
}
m_TmpObjectToAdd = null;
}
}
/// <summary>
/// Adds a <see cref="DetectableGameObject"/> to the settings.
/// </summary>
/// <param name="settingsList">List of <see cref="GameObjectSettings"/></param>
/// <param name="obj"><see cref="DetectableGameObject"/> to add</param>
/// <param name="detectorSpaceType"><see cref="DetectorSpaceType"/>,
/// box (2D) or sphere (3D)</param>
/// <returns>If <see cref="GameObjectSettings"/> were created for
/// <see cref="DetectableGameObject"/></returns>
public bool TryAddDetectableObject(
List <GameObjectSettings> settingsList,
DetectableGameObject obj,
DetectorSpaceType detectorSpaceType)
{
if (!m_Tags.Contains(obj.Tag))
{
settingsList.Add(new GameObjectSettings(obj, detectorSpaceType));
return(true);
}
Debug.LogWarning($"Tag '{obj.Tag}' already added, tags must be distinct.");
return(false);
}
public GameObjectSettings(DetectableGameObject obj)
{
Detectable = obj;
}
/// <summary>
/// Creates the <see cref="GameObjectSettings"/> instance.
/// </summary>
/// <param name="detectable"><see cref="DetectableGameObject"/>
/// the <see cref="GameObjectSettings"/> apply to</param>
public GameObjectSettings(DetectableGameObject detectable, DetectorSpaceType detectorSpaceType)
{
Detectable = detectable;
m_DetectorSpaceType = detectorSpaceType;
}