public IEnumerator ExecutePass(MagicLightProbes parent)
{
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
for (int i = 0; i < parent.tmpNearbyGeometryPoints.Count; i++)
{
GameObject point = GameObject.CreatePrimitive(PrimitiveType.Sphere);
point.name = "Temporary Point " + i;
point.transform.position = parent.tmpNearbyGeometryPoints[i].position;
point.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
point.AddComponent <SphereCollider>().radius = 0.1f;
parent.tmpNearbyGeometryPoints[i].temporaryObject = point;
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpNearbyGeometryPoints.Count))
{
yield return(null);
}
}
}
for (int i = 0; i < parent.tmpNearbyGeometryPoints.Count; i++)
{
if (parent.tmpNearbyGeometryPoints[i].collisionObject != null)
{
parent.tmpNearbyGeometryPoints[i].collisionObject.SetActive(false);
Ray ray = new Ray(parent.tmpNearbyGeometryPoints[i].position, (parent.tmpNearbyGeometryPoints[i].contactPoint - parent.tmpNearbyGeometryPoints[i].position).normalized);
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit, Mathf.Infinity, parent.layerMask))
{
if (raycastHit.collider.name.Contains("Temporary Point"))
{
parent.tmpNearbyGeometryPoints[i].lightLeakLocked = true;
}
}
parent.tmpNearbyGeometryPoints[i].collisionObject.SetActive(true);
}
}
for (int i = 0; i < parent.tmpNearbyGeometryPoints.Count; i++)
{
Object.DestroyImmediate(parent.tmpNearbyGeometryPoints[i].temporaryObject);
}
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, MLPVolume currentVolume)
{
currentVolume.resultLocalCornerPointsPositions.Clear();
ComputeBuffer inputArray;
ComputeBuffer exitArray;
ComputeBuffer directionsArray;
inputArray = new ComputeBuffer(currentVolume.localCornerPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
exitArray = new ComputeBuffer(currentVolume.localCornerPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
directionsArray = new ComputeBuffer(currentVolume.localCornerPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
inputArray.SetData(currentVolume.localCornerPointsPositions.ToArray());
exitArray.SetData(currentVolume.localCornerPointsPositions.ToArray());
directionsArray.SetData(currentVolume.localAvaragedDirections.ToArray());
parent.calculateDistanceFromGeometry.SetBuffer(parent.calculateDistanceFromGeometry.FindKernel("CSMain"), "inputArray", inputArray);
parent.calculateDistanceFromGeometry.SetBuffer(parent.calculateDistanceFromGeometry.FindKernel("CSMain"), "exitArray", exitArray);
parent.calculateDistanceFromGeometry.SetBuffer(parent.calculateDistanceFromGeometry.FindKernel("CSMain"), "directionsArray", directionsArray);
parent.calculateDistanceFromGeometry.SetFloat("distance", parent.unlitVolumeFillingRate);
parent.calculateDistanceFromGeometry.Dispatch(parent.calculateDistanceFromGeometry.FindKernel("CSMain"), 256, 1, 1);
Vector3[] exit = new Vector3[inputArray.count];
exitArray.GetData(exit);
inputArray.Dispose();
exitArray.Dispose();
currentVolume.localCornerPointsPositions.Clear();
for (int i = 0; i < exit.Length; i++)
{
if (exit[i] == Vector3.zero)
{
continue;
}
currentVolume.localCornerPointsPositions.Add(exit[i]);
if (parent.UpdateProgress(exit.Length, 1000))
{
yield return(null);
}
}
}
//private void Init ()
//{
// string[] directories = Directory.GetDirectories(Application.dataPath, "Magic Light Probes/Editor/Icons", SearchOption.AllDirectories);
// string[] str = Directory.GetFiles(directories[0]);
// textureData = File.ReadAllBytes(str[0]);
// logoAsset = new Texture2D(512, 512);
// logoAsset.LoadImage(textureData);
// initialized = true;
//}
public override void OnInspectorGUI()
{
MagicLightProbes magicLightProbes = (MagicLightProbes)target;
if (magicLightProbes.unloaded)
{
magicLightProbes.unloaded = false;
EditorApplication.update -= magicLightProbes.CheckState;
EditorApplication.update += magicLightProbes.CheckState;
}
if (!GeneralMethods.stylesInitialized)
{
GeneralMethods.InitStyles();
}
serializedObject.Update();
GeneralMethods.MLPMainComponentEditor(magicLightProbes);
serializedObject.ApplyModifiedProperties();
EditorUtility.SetDirty(magicLightProbes);
}
private bool CheckIfIsGroundOrFloor(MagicLightProbes parent, Collider checkObject, List <string> keywords)
{
bool result = false;
for (int i = 0; i < keywords.Count; i++)
{
if (checkObject.name.Contains(keywords[i]))
{
result = true;
break;
}
else if (parent.CheckIfTagExist(keywords[i]))
{
if (checkObject.CompareTag(keywords[i]))
{
result = true;
break;
}
}
}
return(result);
}
public IEnumerator ExecutePass(MagicLightProbes parent, TargetPoint targetPoint, MLPVolume currentVolume = null, bool realtimeEditing = false)
{
List <MLPPointData> tempList = new List <MLPPointData>();
List <Vector3> realTimeEditingList = new List <Vector3>();
List <Vector3> targetPoints = new List <Vector3>();
float fillingRate = 0;
switch (targetPoint)
{
case TargetPoint.Unlit:
parent.currentPass = "******";
targetPoints.AddRange(currentVolume.localUnlitPointsPositions);
currentVolume.resultLocalFreePointsPositions.Clear();
currentVolume.resultLocalUnlitPointsPositions.Clear();
fillingRate = parent.unlitVolumeFillingRate;
tempList.AddRange(parent.tmpUnlitPoints);
break;
case TargetPoint.Equivalent:
parent.currentPass = "******";
targetPoints.AddRange(currentVolume.localEquivalentPointsPositions);
currentVolume.resultLocalFreePointsPositions.Clear();
currentVolume.resultLocalEquivalentPointsPositions.Clear();
fillingRate = parent.equivalentVolumeFillingRate;
tempList.AddRange(parent.tmpEqualPoints);
break;
case TargetPoint.Free:
parent.currentPass = "******";
targetPoints.AddRange(currentVolume.localFreePointsPositions);
currentVolume.resultLocalFreePointsPositions.Clear();
currentVolume.resultLocalEquivalentPointsPositions.Clear();
currentVolume.resultLocalUnlitPointsPositions.Clear();
fillingRate = parent.freeVolumeFillingRate;
tempList.AddRange(parent.tmpFreePoints);
break;
}
if (!realtimeEditing)
{
//tempList.Clear
}
realTimeEditingList.AddRange(targetPoints);
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (targetPoints.Count > 0)
{
if (SystemInfo.supportsComputeShaders)
{
ComputeBuffer inputArray;
ComputeBuffer exitArray;
inputArray = new ComputeBuffer(targetPoints.Count, 3 * sizeof(float), ComputeBufferType.Default);
exitArray = new ComputeBuffer(targetPoints.Count, 3 * sizeof(float), ComputeBufferType.Default);
inputArray.SetData(targetPoints.ToArray());
exitArray.SetData(targetPoints.ToArray());
parent.calculateVolumeFilling.SetBuffer(parent.calculateVolumeFilling.FindKernel("CSMain"), "inputArray", inputArray);
parent.calculateVolumeFilling.SetBuffer(parent.calculateVolumeFilling.FindKernel("CSMain"), "exitArray", exitArray);
parent.calculateVolumeFilling.SetFloat("threshold", fillingRate);
parent.calculateVolumeFilling.Dispatch(parent.calculateVolumeFilling.FindKernel("CSMain"), 256, 1, 1);
Vector3[] exit = new Vector3[inputArray.count];
exitArray.GetData(exit);
inputArray.Dispose();
exitArray.Dispose();
for (int i = 0; i < exit.Length; i++)
{
if (exit[i] == Vector3.zero)
{
continue;
}
if (!realtimeEditing)
{
tempList[i].position = exit[i];
parent.tmpSharedPointsArray.Add(tempList[i]);
}
switch (targetPoint)
{
case TargetPoint.Unlit:
currentVolume.resultLocalUnlitPointsPositions.Add(exit[i]);
break;
case TargetPoint.Equivalent:
currentVolume.resultLocalEquivalentPointsPositions.Add(exit[i]);
break;
case TargetPoint.Free:
currentVolume.resultLocalFreePointsPositions.Add(exit[i]);
break;
}
if (parent.UpdateProgress(exit.Length, 1000))
{
yield return(null);
}
}
}
else
{
for (int i = 0; i < Mathf.RoundToInt(targetPoints.Count * (1 - fillingRate)); i++)
{
realTimeEditingList.Remove(realTimeEditingList[UnityEngine.Random.Range(0, realTimeEditingList.Count)]);
if (parent.UpdateProgress(Mathf.RoundToInt(targetPoints.Count * (1 - fillingRate))))
{
yield return(null);
}
}
if (!realtimeEditing)
{
parent.tmpSharedPointsArray.AddRange(tempList);
for (int i = 0; i < tempList.Count; i++)
{
switch (targetPoint)
{
case TargetPoint.Unlit:
currentVolume.resultLocalUnlitPointsPositions.Add(tempList[i].position);
break;
case TargetPoint.Equivalent:
currentVolume.resultLocalEquivalentPointsPositions.Add(tempList[i].position);
break;
case TargetPoint.Free:
currentVolume.resultLocalFreePointsPositions.Add(tempList[i].position);
break;
}
}
}
else
{
for (int i = 0; i < realTimeEditingList.Count; i++)
{
switch (targetPoint)
{
case TargetPoint.Unlit:
currentVolume.resultLocalUnlitPointsPositions.Add(realTimeEditingList[i]);
break;
case TargetPoint.Equivalent:
currentVolume.resultLocalEquivalentPointsPositions.Add(realTimeEditingList[i]);
break;
case TargetPoint.Free:
currentVolume.resultLocalFreePointsPositions.Add(realTimeEditingList[i]);
break;
}
}
}
}
if (targetPoint == TargetPoint.Unlit)
{
if (!realtimeEditing)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
for (int i = 0; i < tempList.Count; i++)
{
if (!tempList[i].lockForCull)
{
parent.CheckForNearContrast(tempList[i]);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(tempList.Count))
{
yield return(null);
}
}
}
}
}
}
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, MLPVolume currentVolume = null)
{
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
parent.debugCulledPoints.Clear();
}
List <MLPPointData> candidatesList = new List <MLPPointData>();
foreach (var light in parent.lights)
{
parent.currentPass = "******"" + light.name + "\"";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1))
{
yield return(null);
}
}
if (
light.lightType == MLPLight.MLPLightType.Directional ||
light.parentVolume == parent ||
(parent.parentVolume != null && light.parentVolume == parent.gameObject))
{
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
switch (light.calculationType)
{
case MLPLight.CalculationType.AccurateShadows:
if (light.accurateTrace)
{
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light))
{
int fullShaded = 0;
foreach (var tracePoint in light.tracePointsData)
{
if (parent.CheckIfInShadow(light, tracePoint, parent.tmpSharedPointsArray[i]))
{
fullShaded++;
}
else
{
fullShaded--;
}
}
if (fullShaded == light.tracePointsData.Count)
{
foreach (var tracePoint in light.tracePointsData)
{
for (int np = 0; np < parent.tmpSharedPointsArray[i].nearbyPoints.Count; np++)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np] != null)
{
if (!parent.CheckIfInShadow(light, tracePoint, parent.tmpSharedPointsArray[i].nearbyPoints[np]))
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].savedNearGeometry)
{
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnShadingArea = true;
if (!parent.tmpContrastShadingBordersPoints.Contains(parent.tmpSharedPointsArray[i].nearbyPoints[np]))
{
parent.tmpContrastShadingBordersPoints.Add(parent.tmpSharedPointsArray[i].nearbyPoints[np]);
}
for (int n = 0; n < parent.tmpSharedPointsArray[i].nearbyPoints[np].nearbyPoints.Count; n++)
{
if (!parent.tmpSharedPointsArray[i].nearbyPoints[np].nearbyPoints[n].savedNearGeometry)
{
parent.tmpSharedPointsArray[i].nearbyPoints[np].nearbyPoints[n].contrastOnShadingArea = true;
if (!parent.tmpContrastShadingBordersPoints.Contains(parent.tmpSharedPointsArray[i].nearbyPoints[np].nearbyPoints[n]))
{
parent.tmpContrastShadingBordersPoints.Add(parent.tmpSharedPointsArray[i].nearbyPoints[np].nearbyPoints[n]);
}
}
}
}
}
else
{
parent.tmpSharedPointsArray[i].contrastOnShadingArea = true;
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnShadingArea = true;
if (!parent.tmpContrastShadingBordersPoints.Contains(parent.tmpSharedPointsArray[i].nearbyPoints[np]))
{
parent.tmpContrastShadingBordersPoints.Add(parent.tmpSharedPointsArray[i].nearbyPoints[np]);
}
if (!parent.tmpContrastShadingBordersPoints.Contains(parent.tmpSharedPointsArray[i]))
{
parent.tmpContrastShadingBordersPoints.Add(parent.tmpSharedPointsArray[i]);
}
}
}
else
{
if (!candidatesList.Contains(parent.tmpSharedPointsArray[i]))
{
candidatesList.Add(parent.tmpSharedPointsArray[i]);
}
}
}
}
}
}
}
else
{
if (!candidatesList.Contains(parent.tmpSharedPointsArray[i]))
{
candidatesList.Add(parent.tmpSharedPointsArray[i]);
}
}
}
else
{
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light))
{
if (parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inCorner)
{
Vector3 shadedPointStartPosition = parent.tmpSharedPointsArray[i].position;
for (int np = 0; np < parent.tmpSharedPointsArray[i].nearbyPoints.Count; np++)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np] != null && parent.tmpSharedPointsArray[i].nearbyPoints[np].inRangeForLights.Contains(light))
{
if (!parent.tmpSharedPointsArray[i].nearbyPoints[np].inShadowForLights.Contains(light) && !parent.tmpSharedPointsArray[i].nearbyPoints[np].inCorner)
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].savedNearGeometry)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np].savedNearGeometry)
{
if (
(parent.tmpSharedPointsArray[i].position - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized !=
(parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized)
{
parent.tmpSharedPointsArray[i].contrastOnShadingArea = true;
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnShadingArea = true;
break;
}
}
}
}
else
{
if ((parent.tmpSharedPointsArray[i].position - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized !=
(parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized)
{
parent.tmpSharedPointsArray[i].contrastOnShadingArea = true;
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnShadingArea = true;
}
}
}
}
}
}
}
}
break;
}
}
}
}
if (parent.debugMode)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
foreach (var point in parent.tmpSharedPointsArray)
{
if (point.contrastOnShadingArea)
{
if (!parent.tmpContrastShadingBordersPoints.Contains(point))
{
parent.tmpContrastShadingBordersPoints.Add(point);
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
switch (parent.debugPass)
{
case MagicLightProbes.DebugPasses.ShadingBorders:
parent.debugAcceptedPoints.AddRange(parent.tmpContrastShadingBordersPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.ContrastAreas:
parent.debugAcceptedPoints.AddRange(parent.tmpContrastOnOutOfRangePoints);
parent.debugAcceptedPoints.AddRange(parent.tmpContrastShadingBordersPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.LightIntensity:
case MagicLightProbes.DebugPasses.EqualProbes:
parent.debugAcceptedPoints.AddRange(parent.tmpContrastOnOutOfRangePoints);
parent.debugAcceptedPoints.AddRange(parent.tmpContrastShadingBordersPoints);
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.UnlitProbes:
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
}
}
else
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <MLPPointData> tempList = new List <MLPPointData>();
tempList.AddRange(parent.tmpSharedPointsArray);
foreach (var point in tempList)
{
if (point.contrastOnShadingArea)
{
parent.tmpContrastShadingBordersPoints.Add(point);
parent.tmpSharedPointsArray.Remove(point);
//currentVolume.localContrastPoints.Add(point);
}
if (point.savedNearGeometry)
{
parent.tmpSharedPointsArray.Remove(point);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(tempList.Count, 1000))
{
yield return(null);
}
}
}
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, float volumeSpacing, float cornersDetectionThreshold, MLPVolume currentVolume = null)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <MLPPointData> addedPoints = new List <MLPPointData>();
List <MLPPointData> removedPoints = new List <MLPPointData>();
GameObject cameraObject = new GameObject("Temp Camera");
Camera renderCamera = cameraObject.AddComponent <Camera>();
renderCamera.cullingMask = parent.layerMask;
Texture2D tex = new Texture2D(128, 128, TextureFormat.RGB24, false);
RenderTexture renderTexture = new RenderTexture(128, 128, 24);
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
SortedList <float, Vector3> results = new SortedList <float, Vector3>();
RaycastHit hitInfo;
Ray[] checkRays =
{
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.forward),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.forward),
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.right),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.right),
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.up),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.up),
};
foreach (var ray in checkRays)
{
if (Physics.Raycast(ray, out hitInfo, volumeSpacing + (volumeSpacing * 0.5f), parent.layerMask)) // parent.volumeSpacing + 0.1f?
{
if (!results.Keys.Contains(hitInfo.distance))
{
if (parent.CheckIfInside(parent.probesVolume.transform, hitInfo.point))
{
bool inSubVolume = false;
foreach (var volume in parent.innerVolumes)
{
if (parent.CheckIfInside(volume, hitInfo.point))
{
inSubVolume = true;
break;
}
}
if (!inSubVolume)
{
results.Add(hitInfo.distance, hitInfo.point);
}
}
}
}
}
if (results.Count > 0)
{
foreach (var result in results)
{
MLPPointData newPoint = new MLPPointData();
Vector3 closestPoint = result.Value;
Ray rayToPoint = new Ray(parent.tmpSharedPointsArray[i].position, (closestPoint - parent.tmpSharedPointsArray[i].position).normalized);
if (Physics.Raycast(rayToPoint, out hitInfo, volumeSpacing + 0.1f, parent.layerMask))
{
if (parent.CheckIfStatic(hitInfo.collider.gameObject))
{
if (hitInfo.collider.gameObject.GetComponent <MLPForceNoProbes>() != null)
{
removedPoints.Add(parent.tmpSharedPointsArray[i]);
continue;
}
removedPoints.Add(parent.tmpSharedPointsArray[i]);
newPoint.position = hitInfo.point;
Vector3 direction = (parent.tmpSharedPointsArray[i].position - newPoint.position).normalized;
newPoint.position += direction * parent.distanceFromNearbyGeometry;
bool tooClose = false;
foreach (var point in currentVolume.localCornerPoints)
{
if (Vector3.Distance(point.position, newPoint.position) < cornersDetectionThreshold)
{
tooClose = true;
break;
}
}
if (!tooClose)
{
renderCamera.targetTexture = renderTexture;
renderCamera.nearClipPlane = 0.01f;
renderCamera.farClipPlane = volumeSpacing * 2;
renderCamera.fieldOfView = 1;
renderCamera.transform.position = newPoint.position;
renderCamera.transform.LookAt(hitInfo.point);
renderCamera.Render();
RenderTexture.active = renderTexture;
tex.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
Color pixel;
float red = 0;
float green = 0;
float blue = 0;
int count = 0;
for (int x = 0; x < renderTexture.width; x++)
{
for (int y = 0; y < renderTexture.height; y++)
{
pixel = tex.GetPixel(x, y);
red += pixel.r;
green += pixel.g;
blue += pixel.b;
count++;
}
}
red /= count;
green /= count;
blue /= count;
Color average = new Color(red, green, blue, 1);
newPoint.col = parent.tmpSharedPointsArray[i].col;
newPoint.row = parent.tmpSharedPointsArray[i].row;
newPoint.depth = parent.tmpSharedPointsArray[i].depth;
newPoint.collisionNormal = hitInfo.normal;
newPoint.savedNearGeometry = true;
newPoint.contactPoint = closestPoint;
newPoint.collisionObject = hitInfo.collider.gameObject;
newPoint.averagedColor = average;
newPoint.xStartPoint = parent.tmpSharedPointsArray[i].xStartPoint;
newPoint.yStartPoint = parent.tmpSharedPointsArray[i].yStartPoint;
newPoint.zStartPoint = parent.tmpSharedPointsArray[i].zStartPoint;
newPoint.xEndPoint = parent.tmpSharedPointsArray[i].xEndPoint;
newPoint.yEndPoint = parent.tmpSharedPointsArray[i].yEndPoint;
newPoint.zEndPoint = parent.tmpSharedPointsArray[i].zEndPoint;
parent.tmpNearbyGeometryPoints.Add(newPoint);
//if (currentVolume != null)
//{
// currentVolume.localDirections.Add(direction);
// currentVolume.localNearbyGeometryPointsPositions.Add(newPoint.position);
//}
RenderTexture.active = null;
}
}
}
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
Object.DestroyImmediate(cameraObject);
if (parent.debugMode)
{
switch (parent.debugPass)
{
case MagicLightProbes.DebugPasses.NearGeometry:
case MagicLightProbes.DebugPasses.GeometryEdges:
case MagicLightProbes.DebugPasses.EqualColor:
parent.debugAcceptedPoints.AddRange(parent.tmpNearbyGeometryPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
default:
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.debugAcceptedPoints.AddRange(parent.tmpNearbyGeometryPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
}
}
else
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
Parallel.For(0, removedPoints.Count, (i, state) =>
{
lock (parent.tmpSharedPointsArray)
{
parent.tmpSharedPointsArray.Remove(removedPoints[i]);
}
});
parent.tmpFreePoints.AddRange(parent.tmpSharedPointsArray);
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
currentVolume.localFreePointsPositions.Add(parent.tmpSharedPointsArray[i].position);
}
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <MLPPointData> removeList = new List <MLPPointData>();
foreach (var point in parent.tmpNearbyGeometryPoints)
{
foreach (var checkPoint in parent.tmpPointsNearGeometryIntersections)
{
if (Vector3.Distance(point.position, checkPoint.position) <= cornersDetectionThreshold * 2.0f)
{
removeList.Add(point);
break;
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpNearbyGeometryPoints.Count, 1000))
{
yield return(null);
}
}
}
Parallel.For(0, removeList.Count, (i, state) =>
{
lock (parent.tmpNearbyGeometryPoints)
{
parent.tmpNearbyGeometryPoints.Remove(removeList[i]);
}
});
//currentVolume.localNearbyGeometryPoints.AddRange(parent.tmpNearbyGeometryPoints);
parent.tmpSharedPointsArray.AddRange(parent.tmpNearbyGeometryPoints);
parent.totalProbesInSubVolume += parent.tmpNearbyGeometryPoints.Count;
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, MLPVolume currentVolume = null, bool realtimeEditing = false)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
List <MLPPointData> tempList = new List <MLPPointData>();
if (realtimeEditing)
{
parent.tmpSharedPointsArray.Clear();
for (int i = 0; i < tempList.Count; i++)
{
tempList[i].equalIntensity = false;
}
}
else
{
tempList.AddRange(parent.tmpSharedPointsArray);
}
int equivalent;
//Parallel.For(0, parent.acceptedPoints.Count, (i, state) =>
for (int i = 0; i < tempList.Count; i++)
{
lock (tempList)
{
if (tempList[i].nearbyPoints.Count > 0)
{
if (!tempList[i].inSaveRange &&
!tempList[i].contrastOnShadingArea &&
!tempList[i].contrastOnOutOfRangeArea &&
!tempList[i].savedNearGeometry)
{
if (!realtimeEditing)
{
//currentVolume.savedPointsForLightIntensityThresholdEditing.Add(tempList[i]);
}
if (tempList[i].lightIntensity > 0)
{
equivalent = 0;
foreach (MLPPointData neigboringPoint in tempList[i].nearbyPoints)
{
if (neigboringPoint != null)
{
if (neigboringPoint.lightIntensity == 0)
{
equivalent = 0;
break;
}
else
{
if (neigboringPoint.lightIntensity.EqualsApproximately(tempList[i].lightIntensity, tempList[i].lightIntensity * (1 - parent.lightIntensityTreshold)))
{
equivalent++;
}
}
}
}
if (equivalent == tempList[i].nearbyPoints.Count)
{
tempList[i].equalIntensity = true;
}
else
{
tempList[i].contrastOnShadingArea = true;
}
}
else
{
equivalent = 0;
foreach (MLPPointData neigboringPoint in tempList[i].nearbyPoints)
{
if (neigboringPoint != null)
{
if (neigboringPoint.lightIntensity > 0)
{
equivalent = 0;
break;
}
else
{
if (!tempList[i].inSaveRange && !tempList[i].savedNearGeometry)
{
equivalent++;
}
}
}
}
if (equivalent == tempList[i].nearbyPoints.Count)
{
tempList[i].equalIntensity = true;
}
else
{
tempList[i].contrastOnShadingArea = true;
}
}
}
}
}
}//);
if (realtimeEditing)
{
parent.tmpEqualPoints.Clear();
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(tempList);
}
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
foreach (var point in tempList)
{
if (point.equalIntensity &&
!point.inSaveRange &&
!point.contrastOnOutOfRangeArea &&
!point.contrastOnShadingArea &&
!point.inCorner &&
!point.savedNearGeometry)
{
if (point.inShadowForLights.Count == parent.lights.Count || point.isUnlit)
{
parent.tmpSharedPointsArray.Remove(point);
}
else
{
parent.tmpSharedPointsArray.Remove(point);
parent.tmpEqualPoints.Add(point);
currentVolume.localEquivalentPointsPositions.Add(point.position);
}
}
else if (point.contrastOnOutOfRangeArea || point.contrastOnShadingArea)
{
currentVolume.localContrastPoints.Add(point);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(tempList.Count, 1000))
{
yield return(null);
}
}
}
tempList.Clear();
if (!parent.debugMode)
{
if (!realtimeEditing)
{
//currentVolume.contrastPointsForQuickEditing.AddRange(parent.acceptedPoints);
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
}
}
else
{
parent.debugAcceptedPoints.AddRange(parent.tmpEqualPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
}
parent.calculatingVolumeSubPass = false;
}
private void Start()
{
parentRootComponent = GetComponentInParent <MagicLightProbes>();
selfRenderer = GetComponent <MeshRenderer>();
}
public IEnumerator ExecutePass(MagicLightProbes parent, List <MLPPointData> inputList)
{
float spacing = 0;
if (parent.useDynamicDensity)
{
if (parent.currentVolume.isSubdividedPart)
{
spacing = parent.volumeSpacingMin;
}
else
{
spacing = parent.volumeSpacingMax;
}
}
else
{
spacing = parent.volumeSpacing;
}
List <List <MLPPointData> > separated = new List <List <MLPPointData> >();
for (int i = 0; i < inputList.Count; i += 1000)
{
separated.Add(inputList.GetRange(i, Math.Min(1000, inputList.Count - i)));
}
for (int s_list = 0; s_list < separated.Count; s_list++)
{
parent.currentPass = "******" + s_list + "/" + separated.Count;
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (!parent.isInBackground)
{
if (parent.UpdateProgress(separated[s_list].Count, 1))
{
yield return(null);
}
}
Parallel.For(0, separated[s_list].Count, i =>
{
foreach (var point in separated[s_list])
{
if (point != separated[s_list][i])
{
if (Vector3.Distance(point.position, separated[s_list][i].position).EqualsApproximately(spacing, 0.01f))
{
separated[s_list][i].nearbyPoints.Add(point);
}
}
}
});
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.AddRange(inputList);
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, float volumeSpacing)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
Thread calculationThread = new Thread(new ThreadStart(() =>
{
Parallel.For(0, parent.tmpSharedPointsArray.Count, (i, state) =>
{
if (!parent.tmpSharedPointsArray[i].contrastOnOutOfRangeArea)
{
foreach (var light in parent.lights)
{
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light))
{
if (light.lightMode != LightmapBakeType.Mixed)
{
if (light.saveNearbyProbes)
{
if (light.accurateTrace)
{
foreach (var tracePoint in light.tracePointsData)
{
if (Vector3.Distance(parent.tmpSharedPointsArray[i].position, tracePoint.position).EqualsApproximately(volumeSpacing, volumeSpacing / 2))
{
parent.tmpSharedPointsArray[i].contrastOnShadingArea = true;
parent.tmpSharedPointsArray[i].SetInSaveRange(true);
parent.tmpNearbyLightsPoints.Add(parent.tmpSharedPointsArray[i]);
break;
}
}
}
else
{
if (Vector3.Distance(parent.tmpSharedPointsArray[i].position, light.position) <= volumeSpacing * 2)
{
parent.tmpSharedPointsArray[i].SetInSaveRange(true);
lock (parent.tmpNearbyLightsPoints)
{
parent.tmpNearbyLightsPoints.Add(parent.tmpSharedPointsArray[i]);
}
}
}
}
}
}
}
}
parent.UpdateProgress(parent.tmpSharedPointsArray.Count);
});
}));
calculationThread.Start();
while (calculationThread.ThreadState == ThreadState.Running)
{
yield return(null);
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.AddRange(parent.tmpNearbyLightsPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, MLPVolume currentVolume = null, bool realtimeEditing = false)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.debugAcceptedPoints.Clear();
}
if (currentVolume.localEquivalentPointsPositions.Count > 0)
{
currentVolume.resultLocalEquivalentPointsPositions.Clear();
ComputeBuffer inputArray;
ComputeBuffer exitArray;
inputArray = new ComputeBuffer(currentVolume.localEquivalentPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
exitArray = new ComputeBuffer(currentVolume.localEquivalentPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
inputArray.SetData(currentVolume.localEquivalentPointsPositions.ToArray());
exitArray.SetData(currentVolume.localEquivalentPointsPositions.ToArray());
parent.calculateVolumeFilling.SetBuffer(parent.calculateVolumeFilling.FindKernel("CSMain"), "inputArray", inputArray);
parent.calculateVolumeFilling.SetBuffer(parent.calculateVolumeFilling.FindKernel("CSMain"), "exitArray", exitArray);
parent.calculateVolumeFilling.SetFloat("threshold", parent.equivalentVolumeFillingRate);
parent.calculateVolumeFilling.Dispatch(parent.calculateVolumeFilling.FindKernel("CSMain"), 256, 1, 1);
Vector3[] exit = new Vector3[inputArray.count];
exitArray.GetData(exit);
inputArray.Dispose();
exitArray.Dispose();
List <MLPPointData> tempList = new List <MLPPointData>();
tempList.AddRange(parent.tmpEqualPoints);
for (int i = 0; i < exit.Length; i++)
{
if (exit[i] == Vector3.zero)
{
continue;
}
if (!realtimeEditing)
{
tempList[i].position = exit[i];
parent.tmpSharedPointsArray.Add(tempList[i]);
}
currentVolume.resultLocalEquivalentPointsPositions.Add(exit[i]);
if (!parent.isInBackground)
{
if (parent.UpdateProgress(exit.Length, 1000))
{
yield return(null);
}
}
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
}
}
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, float volumeSpacing)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
for (int i = 0; i < parent.tmpNearbyGeometryPoints.Count; i++)
{
//GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//temp.transform.localScale = Vector3.one * 0.1f;
parent.layerMasks.Clear();
for (int j = 0; j < parent.staticObjects.Count; j++)
{
parent.layerMasks.Add(parent.staticObjects[j].layer);
if (parent.staticObjects[j] != parent.tmpNearbyGeometryPoints[i].collisionObject)
{
parent.staticObjects[j].gameObject.layer = LayerMask.NameToLayer("Ignore Raycast");
}
}
RaycastHit hitInfo;
Vector3[] directions =
{
Vector3.forward,
-Vector3.forward,
Vector3.right,
-Vector3.right,
Vector3.up,
-Vector3.up
};
bool edgeFound = false;
Vector3 startPosition = new Vector3(
parent.tmpNearbyGeometryPoints[i].position.x,
parent.tmpNearbyGeometryPoints[i].position.y,
parent.tmpNearbyGeometryPoints[i].position.z);
for (int d = 0; d < directions.Length && !edgeFound; d++)
{
float dot = Vector3.Dot(directions[d], -parent.tmpNearbyGeometryPoints[i].collisionNormal);
if (dot.EqualsApproximately(0f, 0.1f))
{
parent.tmpNearbyGeometryPoints[i].position = startPosition;
float prevDistance = Vector3.Distance(startPosition, parent.tmpNearbyGeometryPoints[i].contactPoint);
float currentDistance = 0;
while (Vector3.Distance(startPosition, parent.tmpNearbyGeometryPoints[i].position) <= volumeSpacing && !edgeFound)
{
//Debug.DrawRay(parent.nearbyGeometryPoints[i].position, directions[d], Color.red, 1f);
//temp.transform.position = parent.nearbyGeometryPoints[i].position;
if (Physics.Raycast(new Ray(parent.tmpNearbyGeometryPoints[i].position, -parent.tmpNearbyGeometryPoints[i].collisionNormal), out hitInfo, parent.layerMask))
{
currentDistance = hitInfo.distance;
float difference = Mathf.Abs(prevDistance - currentDistance);
if (difference > 0.5f)
{
parent.tmpNearbyGeometryPoints[i].position -= directions[d] * 0.1f;
parent.tmpNearbyGeometryPoints[i].onGeometryEdge = true;
edgeFound = true;
}
else
{
parent.tmpNearbyGeometryPoints[i].position += directions[d] * 0.05f;
}
prevDistance = currentDistance;
}
else
{
parent.tmpNearbyGeometryPoints[i].position -= directions[d] * 0.1f;
parent.tmpNearbyGeometryPoints[i].onGeometryEdge = true;
edgeFound = true;
}
//while (!parent.nextStep)
//{
// yield return null;
//}
parent.nextStep = false;
}
}
//while (!parent.nextStep)
//{
// yield return null;
//}
parent.nextStep = false;
}
if (!edgeFound)
{
parent.tmpNearbyGeometryPoints[i].position = startPosition;
//Object.DestroyImmediate(temp.gameObject);
}
else
{
//temp.transform.position = parent.nearbyGeometryPoints[i].position;
}
for (int j = 0; j < parent.staticObjects.Count; j++)
{
parent.staticObjects[j].layer = parent.layerMasks[j];
}
//while (!parent.nextStep)
//{
// yield return null;
//}
parent.nextStep = false;
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpNearbyGeometryPoints.Count, 1000))
{
yield return(null);
}
}
}
if (parent.debugMode)
{
List <MLPPointData> exitArray = new List <MLPPointData>();
Parallel.For(0, parent.tmpNearbyGeometryPoints.Count, i =>
{
if (parent.tmpNearbyGeometryPoints[i].onGeometryEdge)
{
lock (exitArray)
{
exitArray.Add(parent.tmpNearbyGeometryPoints[i]);
}
}
});
parent.debugAcceptedPoints.Clear();
parent.debugAcceptedPoints.AddRange(exitArray);
exitArray.Clear();
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
int steps = Mathf.RoundToInt(parent.verticalDublicatingHeight / parent.verticalDublicatingStep);
List <MLPPointData> candidates = new List <MLPPointData>();
List <MLPPointData> savedNearGeometry = new List <MLPPointData>();
parent.tmpSharedPointsArray.AddRange(parent.tmpNearbyGeometryPoints);
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
if (parent.tmpSharedPointsArray[i].savedNearGeometry)
{
if (Vector3.Dot(-Vector3.up, (parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].position).normalized) == 1)
{
candidates.Add(parent.tmpSharedPointsArray[i]);
}
else
{
savedNearGeometry.Add(parent.tmpSharedPointsArray[i]);
}
}
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
parent.tmpSharedPointsArray.Clear();
for (int i = 0; i < steps; i++)
{
parent.currentPass = "******" + i + "/" + steps;
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
foreach (var point in candidates)
{
MLPPointData newPoint = new MLPPointData();
newPoint.position = new Vector3(point.position.x, point.position.y + (parent.verticalDublicatingStep * i), point.position.z);
if (parent.probesVolume.GetComponent <MeshRenderer>().bounds.Contains(newPoint.position))
{
parent.tmpSharedPointsArray.Add(newPoint);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
}
parent.tmpSharedPointsArray.AddRange(candidates);
parent.tmpSharedPointsArray.AddRange(savedNearGeometry);
parent.tmpSharedPointsArray.AddRange(parent.tmpPointsNearGeometryIntersections);
parent.calculatingVolumeSubPass = false;
}
public static void AddVolume(List <MagicLightProbes> allGroups, Vector3 position = new Vector3(), float avaragedSize = 0)
{
GameObject mlpGroupsObject;
mlpGroupsObject = GameObject.Find("Magic Light Probes");
if (mlpGroupsObject == null)
{
mlpGroupsObject = new GameObject("Magic Light Probes");
}
GameObject newProbesVolume = new GameObject("MLP Group " + allGroups.Count, typeof(MagicLightProbes));
newProbesVolume.transform.parent = mlpGroupsObject.transform;
if (position != Vector3.zero)
{
newProbesVolume.transform.position = position;
}
else
{
newProbesVolume.transform.position = SceneView.lastActiveSceneView.camera.transform.position + SceneView.lastActiveSceneView.camera.transform.forward * 5;
}
GameObject probeVolume = GameObject.CreatePrimitive(PrimitiveType.Cube);
probeVolume.name = "MLP Group " + allGroups.Count + " Volume";
probeVolume.AddComponent <MLPVolume>();
probeVolume.transform.parent = newProbesVolume.transform;
probeVolume.GetComponent <MeshRenderer>().lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
probeVolume.GetComponent <MeshRenderer>().reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
probeVolume.GetComponent <MeshRenderer>().enabled = false;
probeVolume.transform.localPosition = Vector3.zero;
if (avaragedSize > 0)
{
probeVolume.transform.localScale = new Vector3(avaragedSize, avaragedSize, avaragedSize);
}
Object.DestroyImmediate(probeVolume.GetComponent <Collider>());
GameObject lightProbeGroup = new GameObject("Light Probe Group " + allGroups.Count, typeof(MLPQuickEditing));
lightProbeGroup.transform.parent = newProbesVolume.transform;
MagicLightProbes mlp = newProbesVolume.GetComponent <MagicLightProbes>();
MLPQuickEditing quickEditing = lightProbeGroup.GetComponent <MLPQuickEditing>();
quickEditing.parent = mlp;
mlp.quickEditingComponent = quickEditing;
mlp.probesVolume = probeVolume;
allGroups.Add(mlp);
if (MLPCombinedVolume.Instance == null)
{
MLPCombinedVolume.CreateCombinedVolumeObject();
}
mlp.combinedVolumeComponent = MLPCombinedVolume.Instance;
}
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;
}
public IEnumerator ExecutePass(MagicLightProbes parent)
{
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
parent.debugCulledPoints.Clear();
}
List <MLPPointData> tempList = new List <MLPPointData>();
List <MLPPointData> addedPoints = new List <MLPPointData>();
foreach (var light in parent.lights)
{
parent.currentPass = "******" + light.name;
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1))
{
yield return(null);
}
}
Parallel.For(0, parent.tmpSharedPointsArray.Count, i =>
{
if (light.saveOnOutOfRange)
{
switch (light.lightType)
{
case MLPLight.MLPLightType.Directional:
break;
default:
if (light.calculationType != MLPLight.CalculationType.LightIntensity)
{
if (light.accurateTrace)
{
foreach (var tracePoint in light.tracePointsData)
{
switch (light.calculationType)
{
case MLPLight.CalculationType.AccurateShadows:
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inCorner)
{
for (int np = 0; np < parent.tmpSharedPointsArray[i].nearbyPoints.Count; np++)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np] != null)
{
if (!parent.tmpSharedPointsArray[i].nearbyPoints[np].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inCorner)
{
if (light.saveOnOutOfRange)
{
if (!parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light))
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np].savedNearGeometry)
{
if ((parent.tmpSharedPointsArray[i].position - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized !=
(parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized)
{
parent.tmpSharedPointsArray[i].contrastOnOutOfRangeArea = true;
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnOutOfRangeArea = true;
}
}
}
else
{
if ((parent.tmpSharedPointsArray[i].position - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized !=
(parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized)
{
parent.tmpSharedPointsArray[i].contrastOnOutOfRangeArea = true;
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnOutOfRangeArea = true;
}
}
}
}
}
}
}
}
break;
}
}
}
else
{
switch (light.calculationType)
{
case MLPLight.CalculationType.AccurateShadows:
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inCorner)
{
for (int np = 0; np < parent.tmpSharedPointsArray[i].nearbyPoints.Count; np++)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np] != null)
{
if (!parent.tmpSharedPointsArray[i].nearbyPoints[np].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inCorner)
{
if (light.saveOnOutOfRange)
{
if (!parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light))
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].nearbyPoints[np].savedNearGeometry)
{
if ((parent.tmpSharedPointsArray[i].position - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized !=
(parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized)
{
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnOutOfRangeArea = true;
parent.tmpSharedPointsArray[i].contrastOnOutOfRangeArea = true;
}
}
}
else
{
if ((parent.tmpSharedPointsArray[i].position - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized !=
(parent.tmpSharedPointsArray[i].contactPoint - parent.tmpSharedPointsArray[i].nearbyPoints[np].position).normalized)
{
parent.tmpSharedPointsArray[i].contrastOnOutOfRangeArea = true;
parent.tmpSharedPointsArray[i].nearbyPoints[np].contrastOnOutOfRangeArea = true;
}
}
}
}
}
}
}
}
break;
}
}
}
break;
}
}
});
}
if (parent.debugMode)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
parent.tmpSharedPointsArray.AddRange(addedPoints);
foreach (var point in parent.tmpSharedPointsArray)
{
if (point != null)
{
if (point.inRangeForLights.Count > 0)
{
tempList.Add(point);
}
else
{
parent.tmpOutOfRangePoints.Add(point);
}
if (point.contrastOnOutOfRangeArea)
{
parent.tmpContrastOnOutOfRangePoints.Add(point);
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
switch (parent.debugPass)
{
case MagicLightProbes.DebugPasses.NearGeometry:
parent.debugAcceptedPoints.AddRange(tempList);
parent.debugAcceptedPoints.AddRange(parent.tmpContrastOnOutOfRangePoints);
parent.debugAcceptedPoints.AddRange(parent.tmpOutOfRangePoints);
break;
case MagicLightProbes.DebugPasses.OutOfRange:
parent.debugAcceptedPoints.AddRange(tempList);
parent.debugCulledPoints.AddRange(parent.tmpOutOfRangePoints);
if (parent.debugPass == MagicLightProbes.DebugPasses.OutOfRange)
{
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;
}
}
break;
case MagicLightProbes.DebugPasses.OutOfRangeBorders:
parent.debugAcceptedPoints.AddRange(parent.tmpContrastOnOutOfRangePoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.NearLights:
case MagicLightProbes.DebugPasses.ShadingBorders:
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.LightIntensity:
case MagicLightProbes.DebugPasses.ContrastAreas:
case MagicLightProbes.DebugPasses.EqualProbes:
parent.debugAcceptedPoints.AddRange(parent.tmpContrastOnOutOfRangePoints);
parent.debugAcceptedPoints.AddRange(tempList);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.UnlitProbes:
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
}
}
else
{
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
}
tempList.Clear();
tempList = null;
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <MLPPointData> pointsToRemove = new List <MLPPointData>();
if (parent.debugMode)
{
if (parent.subVolumesDivided.Count > 0)
{
for (int i = 0; i < parent.debugAcceptedPoints.Count; i++)
{
if (parent.debugAcceptedPoints[i].col == parent.xPointsCount - 1 || parent.debugAcceptedPoints[i].depth == parent.zPointsCount)
{
pointsToRemove.Add(parent.debugAcceptedPoints[i]);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.debugAcceptedPoints.Count))
{
yield return(null);
}
}
}
for (int i = 0; i < pointsToRemove.Count; i++)
{
parent.debugAcceptedPoints.Remove(pointsToRemove[i]);
}
}
}
else
{
if (parent.subVolumesDivided.Count > 0)
{
for (int i = 0; i < parent.tmpNearbyGeometryPoints.Count; i++)
{
if (
parent.tmpNearbyGeometryPoints[i].col == parent.xPointsCount - 1 ||
parent.tmpNearbyGeometryPoints[i].depth == parent.zPointsCount)
{
pointsToRemove.Add(parent.tmpNearbyGeometryPoints[i]);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpNearbyGeometryPoints.Count))
{
yield return(null);
}
}
}
for (int i = 0; i < pointsToRemove.Count; i++)
{
parent.tmpNearbyGeometryPoints.Remove(pointsToRemove[i]);
}
}
//parent.tmpNearbyGeometryPoints.AddRange(parent.tmpPointsNearGeometryIntersections);
}
pointsToRemove.Clear();
parent.calculatingVolumeSubPass = false;
}
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)
{
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.tmpNearbyGeometryPoints.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
int l_counter = 0;
foreach (var light in parent.lights)
{
l_counter++;
parent.currentPass = "******"" + light.name + "\" - " + l_counter + "/" + parent.lights.Count;
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (light.lightType == MLPLight.MLPLightType.Directional || parent.lights.Contains(light))
{
foreach (var tracePoint in light.tracePointsData)
{
tracePoint.pointGameObject.SetActive(false);
}
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
bool calculate = true;
if (light.lightType != MLPLight.MLPLightType.Directional)
{
if (Vector3.Distance(light.position, parent.tmpSharedPointsArray[i].position) > light.range)
{
calculate = false;
}
}
if (calculate)
{
if (light.accurateTrace)
{
int fullShaded = 0;
foreach (var tracePoint in light.tracePointsData)
{
if (parent.CheckIfInShadow(light, tracePoint, parent.tmpSharedPointsArray[i]))
{
fullShaded++;
}
else
{
fullShaded--;
}
}
if (fullShaded == light.tracePointsData.Count)
{
if (!parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light))
{
parent.tmpSharedPointsArray[i].inShadowForLights.Add(light);
}
}
else
{
parent.tmpSharedPointsArray[i].inShadowForLights.Remove(light);
}
}
else
{
parent.CheckIfInShadow(light, light.mainTracePoint, parent.tmpSharedPointsArray[i]);
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
light.gameObject.SetActive(true);
}
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent)
{
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.tmpNearbyGeometryPoints.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
foreach (var light in parent.lights)
{
parent.currentPass = "******" + light.name;
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1))
{
yield return(null);
}
}
if (
light.lightType == MLPLight.MLPLightType.Directional ||
light.parentVolume == parent ||
(parent.parentVolume != null && light.parentVolume == parent.gameObject))
{
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
switch (light.lightType)
{
case MLPLight.MLPLightType.Directional:
parent.tmpSharedPointsArray[i].inRangeForLights.Add(light);
break;
default:
if (light.accurateTrace)
{
foreach (var tracePoint in light.tracePointsData)
{
parent.CheckIfOutOfRange(light, tracePoint, parent.tmpSharedPointsArray[i]);
tracePoint.pointGameObject.SetActive(false);
}
}
else
{
parent.CheckIfOutOfRange(light, light.mainTracePoint, parent.tmpSharedPointsArray[i]);
}
break;
}
}
}
}
if (parent.debugMode)
{
parent.debugAcceptedPoints.Clear();
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
switch (parent.debugPass)
{
case MagicLightProbes.DebugPasses.OutOfRange:
if (parent.tmpSharedPointsArray[i].inRangeForLights.Count > 0)
{
parent.debugAcceptedPoints.Add(parent.tmpSharedPointsArray[i]);
}
else
{
parent.debugCulledPoints.Add(parent.tmpSharedPointsArray[i]);
}
break;
case MagicLightProbes.DebugPasses.OutOfRangeBorders:
case MagicLightProbes.DebugPasses.LightIntensity:
case MagicLightProbes.DebugPasses.UnlitProbes:
case MagicLightProbes.DebugPasses.ShadingBorders:
case MagicLightProbes.DebugPasses.ContrastAreas:
case MagicLightProbes.DebugPasses.EqualProbes:
parent.debugAcceptedPoints.Add(parent.tmpSharedPointsArray[i]);
break;
case MagicLightProbes.DebugPasses.NearLights:
if (parent.tmpSharedPointsArray[i].inRangeForLights.Count > 0)
{
parent.debugAcceptedPoints.Add(parent.tmpSharedPointsArray[i]);
}
break;
}
}
}
parent.calculatingVolumeSubPass = false;
}
private void CalculateProbeSpacing(MagicLightProbes parent, MLPVolume currentVolume, bool realtimeEditing = false)
{
probeSpacingCalculating = true;
#region Test Implementations
//if (currentVolume.localCornerPointsPositions.Count > 0)
//{
// if (realtimeEditing)
// {
// parent.currentPass = "******";
// parent.currentPassProgressCounter = 0;
// parent.currentPassProgressFrameSkipper = 0;
// }
// currentVolume.resultLocalCornerPointsPositions.Clear();
// ComputeBuffer inputArray;
// ComputeBuffer exitArray;
// //ComputeBuffer collisionNormals;
// inputArray = new ComputeBuffer(currentVolume.localCornerPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
// exitArray = new ComputeBuffer(currentVolume.localCornerPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
// //collisionNormals = new ComputeBuffer(currentVolume.localCornerPointsPositions.Count, 3 * sizeof(float), ComputeBufferType.Default);
// inputArray.SetData(currentVolume.localCornerPointsPositions.ToArray());
// exitArray.SetData(currentVolume.localCornerPointsPositions.ToArray());
// //collisionNormals.SetData(tmpCollisionNormals.ToArray());
// parent.calculateProbeSpacing.SetBuffer(parent.calculateProbeSpacing.FindKernel("CSMain"), "inputArray", inputArray);
// parent.calculateProbeSpacing.SetBuffer(parent.calculateProbeSpacing.FindKernel("CSMain"), "exitArray", exitArray);
// //parent.calculateProbeSpacing.SetBuffer(parent.calculateProbeSpacing.FindKernel("CSMain"), "collisionNormals", collisionNormals);
// parent.calculateProbeSpacing.SetFloat("probeSpacing", parent.cornerProbesSpacing);
// parent.calculateProbeSpacing.SetInt("arrayCount", currentVolume.localCornerPointsPositions.Count);
// parent.calculateProbeSpacing.Dispatch(parent.calculateProbeSpacing.FindKernel("CSMain"), 256, 1, 1);
// Vector3[] exit = new Vector3[inputArray.count];
// exitArray.GetData(exit);
// inputArray.Dispose();
// exitArray.Dispose();
// //collisionNormals.Dispose();
// List<MLPPointData> tempList = new List<MLPPointData>();
// tempList.AddRange(parent.tmpPointsNearGeometryIntersections);
// parent.tmpPointsNearGeometryIntersections.Clear();
// for (int i = 0; i < exit.Length; i++)
// {
// if (exit[i] == Vector3.zero)
// {
// continue;
// }
// if (!realtimeEditing)
// {
// tempList[i].position = exit[i];
// parent.tmpPointsNearGeometryIntersections.Add(tempList[i]);
// }
// currentVolume.resultLocalCornerPointsPositions.Add(exit[i]);
// parent.UpdateProgress(exit.Length, 1000);
// }
// tempList.Clear();
//}
//for (int i = 0; i < parent.tmpPointsNearGeometryIntersections.Count; i++)
//{
// for (int j = 0; j < parent.tmpPointsNearGeometryIntersections.Count; j++)
// {
// if (parent.tmpPointsNearGeometryIntersections[j] != parent.tmpPointsNearGeometryIntersections[i])
// {
// float distance = Vector3.Distance(parent.tmpPointsNearGeometryIntersections[i].position, parent.tmpPointsNearGeometryIntersections[j].position);
// float angle = Vector3.Dot(parent.tmpPointsNearGeometryIntersections[i].collisionNormal, parent.tmpPointsNearGeometryIntersections[j].collisionNormal);
// if (distance <= parent.cornerProbesSpacing && angle > 0.9f)
// {
// parent.tmpPointsNearGeometryIntersections.RemoveAt(i);
// }
// }
// }
//}
#endregion
List <MLPPointData> cullList = new List <MLPPointData>();
for (int i = 0; i < currentVolume.localCornerPoints.Count; i++)
{
currentVolume.localCornerPoints[i].lockForCull = false;
currentVolume.localCornerPoints[i].removed = false;
}
for (int i = 0; i < currentVolume.localCornerPoints.Count; i++)
{
if (!currentVolume.localCornerPoints[i].removed)
{
for (int j = 0; j < currentVolume.localCornerPoints.Count; j++)
{
if (currentVolume.localCornerPoints[j] != currentVolume.localCornerPoints[i])
{
float distance = Vector3.Distance(currentVolume.localCornerPoints[i].position, currentVolume.localCornerPoints[j].position);
float angle = Vector3.Dot(currentVolume.localCornerPoints[i].collisionNormal, currentVolume.localCornerPoints[j].collisionNormal);
if (distance <= parent.cornerProbesSpacing && angle > 0.9f && !currentVolume.localCornerPoints[j].lockForCull)
{
currentVolume.localCornerPoints[i].lockForCull = true;
currentVolume.localCornerPoints[j].removed = true;
cullList.Add(currentVolume.localCornerPoints[j]);
}
}
}
}
}
currentVolume.resultLocalCornerPointsPositions.Clear();
for (int i = 0; i < currentVolume.localCornerPoints.Count; i++)
{
if (!cullList.Contains(currentVolume.localCornerPoints[i]))
{
currentVolume.resultLocalCornerPointsPositions.Add(currentVolume.localCornerPoints[i].position);
if (!realtimeEditing)
{
parent.tmpPointsNearGeometryIntersections.Add(currentVolume.localCornerPoints[i]);
}
}
}
probeSpacingCalculating = 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, int volumePartIndex, float cornersDetectionThreshold, MLPVolume currentVolume = null, bool realtimeEditing = false)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
List <TempPointData> tempPointDatas = new List <TempPointData>();
string dirPath = parent.assetEditorPath + "/Scene Data/" + SceneManager.GetActiveScene().name + "/" + parent.name + "/GeometryIntersectionsData";
string fullFilePath = dirPath + "/" + parent.name + "_" + "vol_" + volumePartIndex + "_GeometryIntersectionsData.mlpdat";
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
if (!realtimeEditing)
{
List <MLPPointData> removedPoints = new List <MLPPointData>();
List <Vector3> collisionNormals = new List <Vector3>();
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
Ray[] checkRays =
{
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.forward),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.forward),
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.right),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.right),
new Ray(parent.tmpSharedPointsArray[i].position, Vector3.up),
new Ray(parent.tmpSharedPointsArray[i].position, -Vector3.up),
};
SortedList <float, Vector3> results = new SortedList <float, Vector3>();
RaycastHit hitInfo;
foreach (var ray in checkRays)
{
if (Physics.Raycast(ray, out hitInfo, cornersDetectionThreshold + 0.1f, parent.layerMask))
{
if (parent.CheckIfStatic(hitInfo.collider.gameObject))
{
if (!results.Keys.Contains(hitInfo.distance))
{
results.Add(hitInfo.distance, hitInfo.point);
}
}
}
}
if (results.Count > 1)
{
Vector3 targetPoint = new Vector3();
Vector3 avaragedDirection = new Vector3();
foreach (var result in results)
{
targetPoint.x += result.Value.x;
targetPoint.y += result.Value.y;
targetPoint.z += result.Value.z;
avaragedDirection.x += result.Value.x - parent.tmpSharedPointsArray[i].position.x;
avaragedDirection.y += result.Value.y - parent.tmpSharedPointsArray[i].position.y;
avaragedDirection.z += result.Value.z - parent.tmpSharedPointsArray[i].position.z;
}
targetPoint.x /= results.Count;
targetPoint.y /= results.Count;
targetPoint.z /= results.Count;
avaragedDirection.x /= results.Count;
avaragedDirection.y /= results.Count;
avaragedDirection.z /= results.Count;
avaragedDirection = Vector3.Normalize(avaragedDirection);
Ray rayToPoint = new Ray(parent.tmpSharedPointsArray[i].position, (targetPoint - parent.tmpSharedPointsArray[i].position).normalized);
MLPPointData newPoint = new MLPPointData();
if (Physics.Raycast(rayToPoint, out hitInfo, cornersDetectionThreshold * 2, parent.layerMask))
{
newPoint.position = hitInfo.point;
newPoint.position -= avaragedDirection * parent.distanceFromNearbyGeometry;
newPoint.collisionNormal = hitInfo.normal;
newPoint.inCorner = true;
newPoint.contactPoint = targetPoint;
currentVolume.localCornerPoints.Add(newPoint);
currentVolume.localCornerPointsPositions.Add(newPoint.position);
currentVolume.localAvaragedDirections.Add(avaragedDirection);
tempPointDatas.Add(new TempPointData(newPoint.position, newPoint.collisionNormal));
//if (Vector3.Distance(parent.tmpSharedPointsArray[i].position, hitInfo.point) < parent.cornersDetectionThreshold / 2)
//{
// removedPoints.Add(parent.tmpSharedPointsArray[i]);
// //collisionNormals.Add(newPoint.collisionNormal);
//}
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
if (!parent.debugMode)
{
MLPDataSaver.SaveData(tempPointDatas, fullFilePath);
}
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
CalculateProbeSpacing(parent, currentVolume, realtimeEditing);
while (probeSpacingCalculating)
{
yield return(null);
}
if (parent.debugMode)
{
removedPoints.Clear();
parent.tmpSharedPointsArray.Clear();
switch (parent.debugPass)
{
case MagicLightProbes.DebugPasses.GeometryIntersections:
parent.debugAcceptedPoints.AddRange(parent.tmpPointsNearGeometryIntersections);
break;
case MagicLightProbes.DebugPasses.NearGeometry:
parent.debugAcceptedPoints.AddRange(parent.tmpPointsNearGeometryIntersections);
break;
}
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
}
}
else
{
tempPointDatas = MLPDataSaver.LoadData(tempPointDatas, fullFilePath);
currentVolume.localCornerPoints.Clear();
if (tempPointDatas.Count > 0)
{
for (int i = 0; i < tempPointDatas.Count; i++)
{
MLPPointData tempPoint = new MLPPointData();
tempPoint.position = new Vector3(tempPointDatas[i].xPos, tempPointDatas[i].yPos, tempPointDatas[i].zPos);
tempPoint.collisionNormal = new Vector3(tempPointDatas[i].collisionNormalX, tempPointDatas[i].collisionNormalY, tempPointDatas[i].collisionNormalZ);
currentVolume.localCornerPoints.Add(tempPoint);
}
}
CalculateProbeSpacing(parent, currentVolume, realtimeEditing);
if (!parent.isInBackground)
{
while (probeSpacingCalculating)
{
yield return(null);
}
}
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, int volumePartIndex, MLPVolume currentVolume = null, bool realtimeEditing = false)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (parent.debugMode)
{
parent.tmpNearbyGeometryPoints.Clear();
parent.tmpNearbyGeometryPoints.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
List <TempPointData> tempPointDatas = new List <TempPointData>();
List <MLPPointData> tempList = new List <MLPPointData>();
List <MLPPointData> lockedForCullList = new List <MLPPointData>();
string dirPath = parent.assetEditorPath + "/Scene Data/" + SceneManager.GetActiveScene().name + "/" + parent.name + "/ColorThresholdData";
string fullFilePath = dirPath + "/" + parent.name + "_" + "vol_" + volumePartIndex + "_ColorThresholdData.mlpdat";
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
if (realtimeEditing)
{
tempPointDatas = MLPDataSaver.LoadData(tempPointDatas, fullFilePath);
if (tempPointDatas.Count > 0)
{
for (int i = 0; i < tempPointDatas.Count; i++)
{
MLPPointData pointData = new MLPPointData();
pointData.position = new Vector3(tempPointDatas[i].xPos, tempPointDatas[i].yPos, tempPointDatas[i].zPos);
pointData.averagedColor = new Color(tempPointDatas[i].colorR, tempPointDatas[i].colorG, tempPointDatas[i].colorB);
for (int j = 0; j < tempPointDatas[i].nearbyAvaragedColors.Length; j++)
{
MLPPointData nerabyPoint = new MLPPointData();
nerabyPoint.avaragedColorValue = tempPointDatas[i].nearbyAvaragedColors[j];
pointData.nearbyPoints.Add(nerabyPoint);
}
tempList.Add(pointData);
}
parent.tmpSharedPointsArray.Clear();
for (int i = 0; i < tempList.Count; i++)
{
tempList[i].equalColor = false;
}
}
}
else
{
tempList.AddRange(parent.tmpNearbyGeometryPoints);
}
for (int i = 0; i < tempList.Count; i++)
{
if (!realtimeEditing)
{
if ((tempList[i].collisionObject != null && tempList[i].collisionObject.gameObject.GetComponent <MLPForceSaveProbes>() != null) ||
tempList[i].onGeometryEdge ||
tempList[i].lightLeakLocked)
{
TempPointData tempPoint = new TempPointData(tempList[i].position, tempList[i].averagedColor, new List <float>());
tempPointDatas.Add(tempPoint);
continue;
}
else
{
if (tempList[i].contrastOnShadingArea || tempList[i].contrastOnOutOfRangeArea)
{
if (parent.forceSaveProbesOnShadingBorders)
{
TempPointData tempPoint = new TempPointData(tempList[i].position, tempList[i].averagedColor, new List <float>());
tempPointDatas.Add(tempPoint);
continue;
}
}
}
}
int equivalent = 0;
List <float> tempAvaragedColors = new List <float>();
for (int j = 0; j < tempList[i].nearbyPoints.Count; j++)
{
if (tempList[i].nearbyPoints[j] != null)
{
if (tempList[i].nearbyPoints[j].avaragedColorValue == 0)
{
float averagedColorValue =
(tempList[i].nearbyPoints[j].averagedColor.r +
tempList[i].nearbyPoints[j].averagedColor.g +
tempList[i].nearbyPoints[j].averagedColor.b) / 3;
tempList[i].nearbyPoints[j].avaragedColorValue = averagedColorValue;
}
if (tempList[i].avaragedColorValue == 0)
{
float averagedColorValueCompared =
(tempList[i].averagedColor.r +
tempList[i].averagedColor.g +
tempList[i].averagedColor.b) / 3;
tempList[i].avaragedColorValue = averagedColorValueCompared;
}
if (tempList[i].nearbyPoints[j].avaragedColorValue.EqualsApproximately(tempList[i].avaragedColorValue, parent.colorTreshold))
{
equivalent++;
}
tempAvaragedColors.Add(tempList[i].nearbyPoints[j].avaragedColorValue);
}
}
if (tempList[i].nearbyPoints.Count > 0 && equivalent == tempList[i].nearbyPoints.Count)
{
tempList[i].equalColor = true;
}
if (!realtimeEditing)
{
TempPointData tempPoint = new TempPointData(tempList[i].position, tempList[i].averagedColor, tempAvaragedColors);
tempPointDatas.Add(tempPoint);
//currentVolume.localColorThresholdEditingPoints.Add(tempList[i]);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(tempList.Count, 1000))
{
yield return(null);
}
}
}
if (!realtimeEditing)
{
MLPDataSaver.SaveData(tempPointDatas, fullFilePath);
}
if (!parent.debugMode)
{
if (realtimeEditing)
{
currentVolume.localNearbyGeometryPoints.Clear();
currentVolume.localNearbyGeometryPoints.AddRange(lockedForCullList);
currentVolume.localNearbyGeometryPoints.AddRange(tempList);
}
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
foreach (var point in tempList)
{
if (point.equalColor)
{
if (parent.forceSaveProbesOnShadingBorders)
{
if (!point.contrastOnShadingArea && !point.contrastOnOutOfRangeArea)
{
if (realtimeEditing)
{
currentVolume.localNearbyGeometryPoints.Remove(point);
}
else
{
parent.tmpNearbyGeometryPoints.Remove(point);
}
}
}
else
{
if (realtimeEditing)
{
currentVolume.localNearbyGeometryPoints.Remove(point);
}
else
{
parent.tmpNearbyGeometryPoints.Remove(point);
}
}
}
else
{
if (!realtimeEditing)
{
currentVolume.resultNearbyGeometryPointsPositions.Add(point.position);
}
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(tempList.Count, 1000))
{
yield return(null);
}
}
}
tempList.Clear();
parent.totalProbesInSubVolume = parent.tmpSharedPointsArray.Count;
}
else
{
parent.debugAcceptedPoints.AddRange(parent.tmpNearbyGeometryPoints);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
}
parent.calculatingVolumeSubPass = false;
}
public IEnumerator ExecutePass(MagicLightProbes parent, MLPVolume currentVolume = null)
{
parent.currentPass = "******";
parent.currentPassProgressCounter = 0;
parent.currentPassProgressFrameSkipper = 0;
if (parent.debugMode)
{
parent.tmpSharedPointsArray.Clear();
parent.tmpSharedPointsArray.AddRange(parent.debugAcceptedPoints);
parent.debugAcceptedPoints.Clear();
}
for (int i = 0; i < parent.tmpSharedPointsArray.Count; i++)
{
float resultIntensity = 0;
foreach (var light in parent.lights)
{
RaycastHit hitInfo;
Ray rayToLight = new Ray();
switch (light.lightType)
{
case MLPLight.MLPLightType.Directional:
rayToLight = new Ray(parent.tmpSharedPointsArray[i].position, -light.transform.forward);
if (!Physics.Raycast(rayToLight, out hitInfo, Mathf.Infinity, parent.layerMask))
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].savedNearGeometry)
{
resultIntensity += light.intensity;
}
}
else
{
resultIntensity += light.intensity;
}
}
break;
default:
if (light.accurateTrace)
{
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light))
{
float tracePointWeight = 1f / light.tracePoints.Count;
foreach (var tracePoint in light.tracePointsData)
{
tracePoint.pointGameObject.SetActive(true);
rayToLight = new Ray(parent.tmpSharedPointsArray[i].position, (tracePoint.position - parent.tmpSharedPointsArray[i].position).normalized);
if (Physics.Raycast(rayToLight, out hitInfo, Mathf.Infinity, parent.layerMask))
{
if (hitInfo.collider.name == tracePoint.name)
{
//resultIntensity += tracePointWeight;
resultIntensity += 1.0F / (1.0F + 25.0F * (tracePoint.position - parent.tmpSharedPointsArray[i].position).sqrMagnitude / (light.range * light.range));
parent.tmpSharedPointsArray[i].distancesToLights.Add(hitInfo.distance);
}
}
tracePoint.pointGameObject.SetActive(false);
}
}
}
else
{
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light))
{
rayToLight = new Ray(parent.tmpSharedPointsArray[i].position, (light.transform.position - parent.tmpSharedPointsArray[i].position).normalized);
if (Physics.Raycast(rayToLight, out hitInfo, Mathf.Infinity, parent.layerMask))
{
if (hitInfo.collider.name == light.gameObject.name)
{
if (light.calculationType == MLPLight.CalculationType.AccurateShadows)
{
if (parent.tmpSharedPointsArray[i].inRangeForLights.Contains(light) && !parent.tmpSharedPointsArray[i].inShadowForLights.Contains(light))
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].savedNearGeometry)
{
//resultIntensity += light.intensity;
resultIntensity += 1.0F / (1.0F + 25.0F * (light.position - parent.tmpSharedPointsArray[i].position).sqrMagnitude / (light.range * light.range));
}
}
else
{
//resultIntensity += light.intensity;
resultIntensity += 1.0F / (1.0F + 25.0F * (light.position - parent.tmpSharedPointsArray[i].position).sqrMagnitude / (light.range * light.range));
}
}
}
else
{
if (light.lightMode == LightmapBakeType.Mixed)
{
if (parent.tmpSharedPointsArray[i].savedNearGeometry)
{
//resultIntensity += light.intensity;
resultIntensity += 1.0F / (1.0F + 25.0F * (light.position - parent.tmpSharedPointsArray[i].position).sqrMagnitude / (light.range * light.range));
}
}
else
{
//resultIntensity += light.intensity;
resultIntensity += 1.0F / (1.0F + 25.0F * (light.position - parent.tmpSharedPointsArray[i].position).sqrMagnitude / (light.range * light.range));
}
}
}
}
}
}
break;
}
}
parent.tmpSharedPointsArray[i].SetLightIntensity(resultIntensity);
if (parent.tmpSharedPointsArray[i].lightIntensity == 0 &&
!parent.tmpSharedPointsArray[i].contrastOnOutOfRangeArea &&
!parent.tmpSharedPointsArray[i].contrastOnShadingArea)
{
parent.tmpSharedPointsArray[i].isUnlit = true;
parent.tmpUnlitPoints.Add(parent.tmpSharedPointsArray[i]);
currentVolume.localUnlitPointsPositions.Add(parent.tmpSharedPointsArray[i].position);
}
if (!parent.isInBackground)
{
if (parent.UpdateProgress(parent.tmpSharedPointsArray.Count, 1000))
{
yield return(null);
}
}
}
if (parent.debugMode)
{
switch (parent.debugPass)
{
case MagicLightProbes.DebugPasses.OutOfRangeBorders:
case MagicLightProbes.DebugPasses.ShadingBorders:
case MagicLightProbes.DebugPasses.ContrastAreas:
case MagicLightProbes.DebugPasses.EqualProbes:
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.LightIntensity:
parent.debugAcceptedPoints.AddRange(parent.tmpSharedPointsArray);
parent.totalProbesInSubVolume = parent.debugAcceptedPoints.Count;
break;
case MagicLightProbes.DebugPasses.UnlitProbes:
parent.debugCulledPoints.AddRange(parent.tmpUnlitPoints);
parent.totalProbesInSubVolume = parent.debugCulledPoints.Count;
break;
}
}
parent.calculatingVolumeSubPass = false;
}
