public IEnumerator ExecutePass(MagicLightProbes parent, MagicLightProbes.VolumeParameters volumePart, MagicLightProbes.CalculationTarget calculationTarget)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <MLPPointData> tempList = new List <MLPPointData>();
if (parent.useVolumeBottom)
{
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
if (parent.tmpSharedPointsArray[i].position.y >= volumePart.position.y - (volumePart.demensions.y / 2))
{
tempList.Add(parent.tmpSharedPointsArray[i]);
}
}
}
else
{
NativeArray <RaycastHit> raycastResults = new NativeArray <RaycastHit>(parent.tmpSharedPointsArray.Count, Allocator.TempJob);
NativeArray <RaycastCommand> raycastCommands = new NativeArray <RaycastCommand>(parent.tmpSharedPointsArray.Count, Allocator.TempJob);
Parallel.For(0, parent.tmpSharedPointsArray.Count, i =>
{
if (parent.tmpSharedPointsArray[i] != null)
{
raycastCommands[i] = new RaycastCommand(parent.tmpSharedPointsArray[i].position, Vector3.down, Mathf.Infinity, parent.layerMask);
}
});
JobHandle handle = RaycastCommand.ScheduleBatch(raycastCommands, raycastResults, 1, default);
handle.Complete();
for (int i = 0; i < raycastResults.Length; i++)
{
RaycastHit outInfo = raycastResults[i];
if (outInfo.collider != null)
{
#if TERRAINPACKAGE_EXIST
if (outInfo.collider.GetComponent <Terrain>() != null)
{
if (outInfo.distance <= parent.maxHeightAboveTerrain)
{
tempList.Add(parent.tmpSharedPointsArray[i]);
}
else
{
if (parent.debugMode)
{
parent.tmpOutOfMaxHeightPoints.Add(parent.tmpSharedPointsArray[i]);
}
}
}
else
{
//RaycastHit[] topDownRaycastResults = RaycastAllNonConvex(parent.tmpSharedPointsArray[i].position, parent.layerMask);
RaycastHit[] topDownRaycastResults = Physics.RaycastAll(parent.tmpSharedPointsArray[i].position, Vector3.down, Mathf.Infinity, parent.layerMask);
if (topDownRaycastResults.Length > 0)
{
for (int j = 0; j < topDownRaycastResults.Length; j++)
{
if (CheckIfIsGroundOrFloor(parent, topDownRaycastResults[j].collider, parent.groundAndFloorKeywords))
{
if (outInfo.distance <= parent.maxHeightAboveGeometry)
{
tempList.Add(parent.tmpSharedPointsArray[i]);
}
else
{
if (parent.debugMode)
{
parent.tmpOutOfMaxHeightPoints.Add(parent.tmpSharedPointsArray[i]);
}
}
break;
}
}
}
}
#else
//RaycastHit[] topDownRaycastResults = RaycastAllNonConvex(parent.tmpSharedPointsArray[i].position, parent.layerMask);
RaycastHit[] topDownRaycastResults = Physics.RaycastAll(parent.tmpSharedPointsArray[i].position, Vector3.down, Mathf.Infinity, parent.layerMask);
if (topDownRaycastResults.Length > 0)
{
for (int j = 0; j < topDownRaycastResults.Length; j++)
{
if (CheckIfIsGroundOrFloor(parent, topDownRaycastResults[j].collider, parent.groundAndFloorKeywords))
{
if (outInfo.distance <= parent.maxHeightAboveGeometry)
{
tempList.Add(parent.tmpSharedPointsArray[i]);
}
else
{
if (parent.debugMode)
{
parent.tmpOutOfMaxHeightPoints.Add(parent.tmpSharedPointsArray[i]);
}
}
break;
}
}
}
#endif
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
raycastResults.Dispose();
raycastCommands.Dispose();
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.AddRange(tempList);
parent.debugCulledPoints.AddRange(parent.tmpOutOfMaxHeightPoints);
if (parent.debugPass == MagicLightProbes.DebugPasses.MaximumHeight)
{
switch (parent.drawMode)
{
case MagicLightProbes.DrawModes.Accepted:
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DrawModes.Culled:
parent.totalProbesInSubVolume = parent.debugCulledPoints.Count;
break;
case MagicLightProbes.DrawModes.Both:
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count + parent.debugCulledPoints.Count;
break;
}
}
else
{
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
}
}
else
{
parent.tmpOutOfMaxHeightPoints.Clear();
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(tempList);
tempList.Clear();
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, MagicLightProbes.VolumeParameters volumePart, MagicLightProbes.CalculationTarget calculationTarget)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <MLPPointData> tempAcceptedList = new List <MLPPointData>();
List <MLPPointData> tempCulledList = new List <MLPPointData>();
bool physicsOptionsChanged = false;
if (Physics.queriesHitBackfaces)
{
Physics.queriesHitBackfaces = false;
physicsOptionsChanged = true;
}
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
parent.debugCulledPoints.Clear();
}
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
Collider[] colliders = Physics.OverlapSphere(parent.tmpSharedPointsArray[i].position, parent.collisionDetectionRadius, parent.layerMask);
if (colliders.Length == 0)
{
Ray[] checkRays =
{
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.down),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.down),
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.right),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.right),
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.forward),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.forward)
};
int freeRays = 0;
foreach (var ray in checkRays)
{
RaycastHit hitInfoForward;
RaycastHit hitInfoBackward;
Vector3 endPoint = parent.tmpSharedPointsArray[i].position + (ray.direction * 5000.0f);
Ray backRay = new Ray(endPoint, (ray.origin - endPoint).normalized);
if (Physics.Raycast(ray, out hitInfoForward, 5000.0f, parent.layerMask))
{
if (parent.CheckIfStatic(hitInfoForward.collider.gameObject))
{
if (Physics.Raycast(new Ray(hitInfoForward.point, (parent.tmpSharedPointsArray[i].position - hitInfoForward.point).normalized), out hitInfoBackward, 5000.0f, parent.layerMask))
{
if (parent.CheckIfStatic(hitInfoForward.collider.gameObject))
{
if (hitInfoForward.distance <= hitInfoBackward.distance)
{
freeRays++;
}
}
else
{
freeRays++;
}
}
else
{
freeRays++;
}
}
else
{
freeRays++;
}
}
else
{
if (Physics.Raycast(backRay, out hitInfoBackward, 5000.0f, parent.layerMask))
{
float dist = Vector3.Distance(parent.tmpSharedPointsArray[i].position, endPoint);
if (hitInfoBackward.distance >= 5000.0f)
{
freeRays++;
}
}
else
{
freeRays++;
}
}
}
if (freeRays == checkRays.Length)
{
tempAcceptedList.Add(parent.tmpSharedPointsArray[i]);
}
else
{
tempCulledList.Add(parent.tmpSharedPointsArray[i]);
}
}
else
{
foreach (var collider in colliders)
{
if (parent.CheckIfStatic(collider.gameObject))
{
if (!tempCulledList.Contains(parent.tmpSharedPointsArray[i]))
{
tempCulledList.Add(parent.tmpSharedPointsArray[i]);
}
}
else
{
tempAcceptedList.Add(parent.tmpSharedPointsArray[i]);
}
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
if (physicsOptionsChanged)
{
Physics.queriesHitBackfaces = true;
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.AddRange(tempAcceptedList);
parent.debugCulledPoints.AddRange(tempCulledList);
if (parent.debugPass == MagicLightProbes.DebugPasses.GeometryCollision)
{
switch (parent.drawMode)
{
case MagicLightProbes.DrawModes.Accepted:
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DrawModes.Culled:
parent.totalProbesInSubVolume = parent.debugCulledPoints.Count;
break;
case MagicLightProbes.DrawModes.Both:
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count + parent.debugCulledPoints.Count;
break;
}
}
else
{
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
}
}
else
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(tempAcceptedList);
tempAcceptedList.Clear();
tempCulledList.Clear();
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, float spacing, MagicLightProbes.VolumeParameters volumePart, MagicLightProbes.CalculationTarget calculationTarget)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
MLPPointData pointData;
parent.recalculationRequired = false;
var offset = volumePart.position;
var stepX = Mathf.FloorToInt(volumePart.demensions.x / spacing);
var stepY = Mathf.FloorToInt(volumePart.demensions.y / spacing);
var stepZ = Mathf.FloorToInt(volumePart.demensions.z / spacing) + 1;
parent.xPointsCount = stepX;
parent.yPointsCount = stepY;
parent.zPointsCount = stepZ;
offset -= volumePart.demensions * 0.5f;
offset.x += (volumePart.demensions.x - stepX * spacing) * 0.5f;
offset.y += (volumePart.demensions.y - stepY * spacing) * 0.5f;
offset.z += (volumePart.demensions.z - stepZ * spacing) * 0.5f;
for (int x = 0; x < stepX; x++)
{
for (int y = 0; y < stepY; y++)
{
for (int z = 0; z < stepZ; z++)
{
var pointPosition = offset + new Vector3(x * spacing, y * spacing, z * spacing);
pointData = new MLPPointData();
pointData.position = pointPosition;
pointData.col = x;
pointData.row = y;
pointData.depth = z;
if (parent.innerVolumes.Count > 0)
{
int containsIn = 0;
foreach (var volume in parent.innerVolumes)
{
if (parent.CheckIfInside(volume, pointPosition))
{
containsIn++;
}
}
if (containsIn == 0)
{
parent.tmpSharedPointsArray.Add(pointData);
parent.totalProbes++;
}
}
else
{
parent.tmpSharedPointsArray.Add(pointData);
parent.totalProbes++;
}
parent.UpdateProgress(stepX * stepY * stepZ);
}
}
}
if (!parent.isInBackground)
{
yield return(null);
}
parent.calculatingVolumeSubPass = false;
}
