private static void DrawGizmoOnSelection(MLPVolume volume, GizmoType gizmoType)
{
if (volume.showGizmoSelected)
{
DrawVolumeWithBounds(volume, new Color(1, 1, 0, 0.5f), Color.yellow);
}
}
private void OnSceneGUI()
{
MLPVolume mlpVolume = (MLPVolume)target;
EventType currentEvent = Event.current.type;
if (currentEvent == EventType.MouseUp)
{
mlpVolume.parentRootComponent.changed = true;
}
boxBoundsHandle.axes = PrimitiveBoundsHandle.Axes.X | PrimitiveBoundsHandle.Axes.Y | PrimitiveBoundsHandle.Axes.Z;
boxBoundsHandle.wireframeColor = Color.yellow;
boxBoundsHandle.center = mlpVolume.transform.position;
boxBoundsHandle.size = mlpVolume.transform.localScale;
//Handles.matrix = mlpVolume.transform.localToWorldMatrix;
EditorGUI.BeginChangeCheck();
boxBoundsHandle.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(mlpVolume, "MLP Change Bounds");
mlpVolume.transform.position = boxBoundsHandle.center;
mlpVolume.transform.localScale = boxBoundsHandle.size;
}
}
private static void DrawVolumeWithOnlyBounds(MLPVolume volume, Color boundsColor)
{
//Gizmos.matrix = volume.transform.localToWorldMatrix;
Gizmos.color = boundsColor;
Gizmos.DrawWireCube(volume.transform.parent.position, volume.transform.parent.localScale);
}
public override void OnInspectorGUI()
{
MLPVolume mlpVolume = (MLPVolume)target;
GUILayout.BeginVertical(GUI.skin.box);
GUILayout.BeginHorizontal();
GUILayout.Label("Sub-Volumes Count", GUILayout.MinWidth(200));
GUILayout.Label(mlpVolume.parentRootComponent.subVolumesDivided.Count.ToString());
GUILayout.EndHorizontal();
if (mlpVolume.parentRootComponent.tooManySubVolumes)
{
GUILayout.BeginHorizontal();
EditorGUILayout.HelpBox("The main volume contains too many sub-volumes. \r\n\r\n" +
"What can you do: \r\n" +
" - Increase the \"Probes Count Limit\"\r\n" +
" - Change the spacing settings (\"Probe Spacing\" or \"Corners Detection Threshold\") \r\n" +
" - Reduce volume sizes)", MessageType.Error);
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
}
private static void DrawGizmoAlways(MLPVolume volume, GizmoType gizmoType)
{
if (volume.parentRootComponent.calculatingVolume)
{
if (volume.parentRootComponent.subVolumesDivided.Count > 0)
{
if (volume.isPartVolume)
{
if (volume.skipped)
{
DrawVolumeWithBounds(volume, Color.red, Color.red);
return;
}
if (volume.isCalculated)
{
DrawVolumeWithOnlyBounds(volume, Color.yellow);
}
else
{
if (volume.isInProcess)
{
DrawVolumeWithBounds(volume, Color.yellow, Color.red);
}
else
{
DrawVolumeWithOnlyBounds(volume, Color.yellow);
}
}
}
}
else
{
if (volume.isInProcess)
{
DrawVolumeWithBounds(volume, Color.yellow, Color.yellow);
}
else
{
DrawVolumeWithBounds(volume, Color.red, Color.yellow);
}
}
}
else
{
if (volume.showGizmo)
{
DrawVolumeWithBounds(volume, new Color(0, 1, 0, 0.5f), Color.yellow);
}
}
}
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);
}
}
}
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, 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;
}
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, 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;
}
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, 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, 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)
{
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;
}
