// -------------------------------------------------- //
// INTERNAL METHODS //
// -------------------------------------------------- //
private void SerializeRecursive(ref List <SerializableVolume> serializableVolumes, int parentID, out int volumeID)
{
// Serialize this volume
volumeID = serializableVolumes.Count;
SerializableVolume volume = new SerializableVolume()
{
positionWS = positionWS,
rotationWS = Quaternion.identity,
volumeID = volumeID,
scaleWS = scaleWS,
parentID = parentID
};
serializableVolumes.Add(volume);
// If no children we are finished
if (children == null)
{
return;
}
// Recursively serialize its children
volume.childIDs = new int[children.Length];
for (int i = 0; i < children.Length; i++)
{
var childIndex = -1;
children[i].SerializeRecursive(ref serializableVolumes, volumeID, out childIndex);
volume.childIDs[i] = childIndex;
}
}
/// <summary>
/// Get a random position within the bounds of a Volume in world space. Editor only.
/// </summary>
/// <param name="volume">Volume to use for bounds.</param>
public static Vector3 GetRandomPointWithinVolume(SerializableVolume volume)
{
var x = UnityEngine.Random.Range(volume.positionWS.x - (volume.scaleWS.x / 2), volume.positionWS.x + (volume.scaleWS.x / 2));
var y = UnityEngine.Random.Range(volume.positionWS.y - (volume.scaleWS.y / 2), volume.positionWS.y + (volume.scaleWS.y / 2));
var z = UnityEngine.Random.Range(volume.positionWS.z - (volume.scaleWS.z / 2), volume.positionWS.z + (volume.scaleWS.z / 2));
return(new Vector3(x, y, z));
}
private void UpdateOcclusion()
{
// Get an array of all unique active volumes
var activeVolumes = new SerializableVolume[m_ActiveAgents.Count];
for (int i = 0; i < activeVolumes.Length; i++)
{
activeVolumes[i] = m_PortalData.volumes[m_ActiveAgents[i].activeVolumeID];
}
var uniqueActiveVolumes = activeVolumes.Select(s => s.volumeID).Where(s => s != -1).Distinct().ToArray();
// Get all Visibility data from active volumes
var activeVisibility = new List <VisbilityData>();
foreach (VisbilityData visibility in m_PortalData.visibilityTable)
{
if (uniqueActiveVolumes.Contains(visibility.volume.volumeID))
{
activeVisibility.Add(visibility);
}
}
// Disable all visible renderers not in this active Volume
var visibleRenderers = m_VisibleRenderers.Values.ToArray();
var allVisibilityRenderers = activeVisibility.SelectMany(i => i.renderers).Distinct().ToArray();
foreach (MeshRenderer renderer in visibleRenderers)
{
if (!allVisibilityRenderers.Contains(renderer))
{
renderer.enabled = false;
}
}
// Enable all Renderers in the active Volumes that arent current visible
MeshRenderer disposablerenderer;
m_VisibleRenderers.Clear();
int[] IDs = new int[allVisibilityRenderers.Length];
for (int i = 0; i < allVisibilityRenderers.Length; i++)
{
IDs[i] = allVisibilityRenderers[i].GetInstanceID();
if (!m_VisibleRenderers.TryGetValue(allVisibilityRenderers[i].gameObject.GetInstanceID(), out disposablerenderer))
{
allVisibilityRenderers[i].enabled = true;
}
}
// Update visible renderers to match active Volumes
for (int i = 0; i < allVisibilityRenderers.Length; i++)
{
m_VisibleRenderers.Add(IDs[i], allVisibilityRenderers[i]);
}
}
/// <summary>
/// Try to the Value of a VisibilityData as MeshRenderer[] from a List.
/// </summary>
/// <param name="volume">SerializableVolume to use as Key.</param>
/// <param name="renderers">MeshRenderer[] returns if true.</param>
public static bool TryGetRenderers(this List <VisbilityData> list, SerializableVolume volume, out MeshRenderer[] renderers)
{
for (int i = 0; i < list.Count; i++)
{
if (list[i].volume.volumeID == volume.volumeID)
{
renderers = list[i].renderers;
return(true);
}
}
renderers = null;
return(false);
}
// --------------------------------------------------
// VOLUME DATA
private static SerializableVolume[] GetVolumeDataManual(int startID = 0)
{
// Get all VolumeOccluders in scene
var manualVolumeObjects = UnityEngine.Object.FindObjectsOfType <PortalVolume>();
// Serialize
var manualVolumeData = new SerializableVolume[manualVolumeObjects.Length];
for (int i = 0; i < manualVolumeData.Length; i++)
{
manualVolumeData[i] = manualVolumeObjects[i].Serialize(startID + i);
}
return(manualVolumeData);
}
// -------------------------------------------------- //
// CONSTRUCTOR //
// -------------------------------------------------- //
public VisbilityData(SerializableVolume volume, GameObject[] objects, Debug[] debugData)
{
this.volume = volume;
this.objects = objects;
this.debugData = debugData;
}
