public override void OnInspectorGUI()
{
ProbeVolume probeVolume = target as ProbeVolume;
bool hasChanges = false;
if (probeVolume.cachedTransform != probeVolume.gameObject.transform.worldToLocalMatrix)
{
hasChanges = true;
}
if (!probeVolume.cachedParameters.IsEquivalent(probeVolume.parameters))
{
hasChanges = true;
}
probeVolume.mightNeedRebaking = hasChanges;
var renderPipelineAsset = GraphicsSettings.renderPipelineAsset;
if (renderPipelineAsset != null && renderPipelineAsset.GetType().Name == "HDRenderPipelineAsset")
{
serializedObject.Update();
ProbeVolumeUI.Inspector.Draw(m_SerializedProbeVolume, this);
}
else
{
EditorGUILayout.HelpBox("Probe Volume is not a supported feature by this SRP.", MessageType.Error, wide: true);
}
m_SerializedProbeVolume.Apply();
}
protected void OnSceneGUI()
{
ProbeVolume probeVolume = target as ProbeVolume;
//important: if the origin of the handle's space move along the handle,
//handles displacement will appears as moving two time faster.
using (new Handles.DrawingScope(Matrix4x4.TRS(Vector3.zero, probeVolume.transform.rotation, Vector3.one)))
{
//contained must be initialized in all case
s_ShapeBox.center = Quaternion.Inverse(probeVolume.transform.rotation) * probeVolume.transform.position;
s_ShapeBox.size = probeVolume.parameters.size;
s_ShapeBox.monoHandle = false;
EditorGUI.BeginChangeCheck();
s_ShapeBox.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(new Object[] { probeVolume, probeVolume.transform }, "Change Probe Volume Bounding Box");
probeVolume.parameters.size = s_ShapeBox.size;
Vector3 delta = probeVolume.transform.rotation * s_ShapeBox.center - probeVolume.transform.position;
probeVolume.transform.position += delta;;
}
}
}
static void DrawGizmosSelected(ProbeVolume probeVolume, GizmoType gizmoType)
{
using (new Handles.DrawingScope(Matrix4x4.TRS(probeVolume.transform.position, probeVolume.transform.rotation, Vector3.one)))
{
// Blend box
if (!blendBoxes.TryGetValue(probeVolume, out HierarchicalBox blendBox))
{
return;
}
blendBox.center = CenterBlendLocalPosition(probeVolume);
blendBox.size = BlendSize(probeVolume);
Color baseColor = probeVolume.parameters.debugColor;
baseColor.a = 8 / 255f;
blendBox.baseColor = baseColor;
blendBox.DrawHull(EditMode.editMode == k_EditBlend);
// Bounding box.
if (!shapeBoxes.TryGetValue(probeVolume, out HierarchicalBox shapeBox))
{
return;
}
shapeBox.center = Vector3.zero;
shapeBox.size = probeVolume.parameters.size;
shapeBox.DrawHull(EditMode.editMode == k_EditShape);
}
}
static void DrawGizmosSelected(ProbeVolume probeVolume, GizmoType gizmoType)
{
using (new Handles.DrawingScope(Matrix4x4.TRS(probeVolume.transform.position, probeVolume.transform.rotation, Vector3.one)))
{
// Bounding box.
s_ShapeBox.center = Vector3.zero;
s_ShapeBox.size = probeVolume.parameters.size;
s_ShapeBox.DrawHull(EditMode.editMode == k_EditShape);
}
}
static Vector3 BlendSize(ProbeVolume probeVolume)
{
Vector3 size = probeVolume.parameters.size;
Vector3 blendSize = (Vector3.one - probeVolume.parameters.positiveFade - probeVolume.parameters.negativeFade);
blendSize.x *= size.x;
blendSize.y *= size.y;
blendSize.z *= size.z;
return(blendSize);
}
public override void OnInspectorGUI()
{
ProbeVolume probeVolume = target as ProbeVolume;
bool hasChanges = false;
if (probeVolume.cachedTransform != probeVolume.gameObject.transform.worldToLocalMatrix)
{
hasChanges = true;
}
if (probeVolume.cachedHashCode != probeVolume.GetHashCode())
{
hasChanges = true;
}
probeVolume.mightNeedRebaking = hasChanges;
bool drawInspector = true;
if (ProbeReferenceVolume._GetLightingSettingsOrDefaultsFallback.Invoke().realtimeGI)
{
EditorGUILayout.HelpBox("The Probe Volume feature is not supported when using Enlighten.", MessageType.Warning, wide: true);
drawInspector = false;
}
var renderPipelineAsset = GraphicsSettings.renderPipelineAsset;
if (!ProbeReferenceVolume.instance.isInitialized || !ProbeReferenceVolume.instance.enabledBySRP)
{
if (renderPipelineAsset == null || renderPipelineAsset.GetType().Name != "HDRenderPipelineAsset")
{
EditorGUILayout.HelpBox("Probe Volume is not a supported feature by this SRP.", MessageType.Error, wide: true);
}
else
{
EditorGUILayout.HelpBox("The probe volumes feature is not enabled or not available on current SRP.", MessageType.Warning, wide: true);
}
drawInspector = false;
}
if (drawInspector)
{
serializedObject.Update();
ProbeVolumeUI.Inspector.Draw(m_SerializedProbeVolume, this);
}
m_SerializedProbeVolume.Apply();
}
static void DrawGizmosSelected(ProbeVolume probeVolume, GizmoType gizmoType)
{
using (new Handles.DrawingScope(Matrix4x4.TRS(probeVolume.transform.position, probeVolume.transform.rotation, Vector3.one)))
{
// Bounding box.
if (!shapeBoxes.TryGetValue(probeVolume, out HierarchicalBox shapeBox))
{
return;
}
shapeBox.center = Vector3.zero;
shapeBox.size = probeVolume.parameters.size;
shapeBox.DrawHull(EditMode.editMode == k_EditShape);
}
}
static Vector3 CenterBlendLocalPosition(ProbeVolume probeVolume)
{
Vector3 size = probeVolume.parameters.size;
Vector3 posBlend = probeVolume.parameters.positiveFade;
posBlend.x *= size.x;
posBlend.y *= size.y;
posBlend.z *= size.z;
Vector3 negBlend = probeVolume.parameters.negativeFade;
negBlend.x *= size.x;
negBlend.y *= size.y;
negBlend.z *= size.z;
Vector3 localPosition = (negBlend - posBlend) * 0.5f;
return(localPosition);
}
static void Drawer_BakeToolBar(SerializedProbeVolume serialized, Editor owner)
{
if (!ProbeReferenceVolume.instance.isInitialized)
{
return;
}
ProbeVolume pv = (serialized.serializedObject.targetObject as ProbeVolume);
Bounds bounds = new Bounds();
bool foundABound = false;
bool performFitting = false;
bool performFittingOnlyOnScene = false;
bool performFittingOnlyOnSelection = false;
bool ContributesToGI(Renderer renderer)
{
var flags = GameObjectUtility.GetStaticEditorFlags(renderer.gameObject) & StaticEditorFlags.ContributeGI;
return((flags & StaticEditorFlags.ContributeGI) != 0);
}
void ExpandBounds(Bounds currBound)
{
if (!foundABound)
{
bounds = currBound;
foundABound = true;
}
else
{
bounds.Encapsulate(currBound);
}
}
EditorGUI.BeginDisabledGroup(pv.globalVolume);
if (GUILayout.Button(EditorGUIUtility.TrTextContent("Fit to all Scenes", "Fits the Probe Volume's boundary to all open Scenes"), EditorStyles.miniButton))
{
performFitting = true;
}
if (GUILayout.Button(EditorGUIUtility.TrTextContent("Fit to Scene", "Fits the Probe Volume's boundary to the Scene it belongs to."), EditorStyles.miniButton))
{
performFitting = true;
performFittingOnlyOnScene = true;
}
if (GUILayout.Button(EditorGUIUtility.TrTextContent("Fit to Selection", "Fits the Probe Volume's boundary to the selected GameObjects. Lock the Probe Volume's Inspector to allow for the selection of other GameObjects."), EditorStyles.miniButton))
{
performFitting = true;
performFittingOnlyOnSelection = true;
}
EditorGUI.EndDisabledGroup();
if (performFitting)
{
Undo.RecordObject(pv.transform, "Fitting Probe Volume");
if (performFittingOnlyOnSelection)
{
var transforms = Selection.transforms;
foreach (var transform in transforms)
{
var childrens = transform.gameObject.GetComponentsInChildren <Transform>();
foreach (var children in childrens)
{
Renderer childRenderer;
if (children.gameObject.TryGetComponent <Renderer>(out childRenderer))
{
bool childContributeGI = ContributesToGI(childRenderer) && childRenderer.gameObject.activeInHierarchy && childRenderer.enabled;
if (childContributeGI)
{
ExpandBounds(childRenderer.bounds);
}
}
}
}
}
else
{
var renderers = UnityEngine.GameObject.FindObjectsOfType <Renderer>();
foreach (Renderer renderer in renderers)
{
bool useRendererToExpand = false;
bool contributeGI = ContributesToGI(renderer) && renderer.gameObject.activeInHierarchy && renderer.enabled;
if (contributeGI)
{
useRendererToExpand = performFittingOnlyOnScene ? (renderer.gameObject.scene == pv.gameObject.scene) : true;
}
if (useRendererToExpand)
{
ExpandBounds(renderer.bounds);
}
}
}
pv.transform.position = bounds.center;
float minBrickSize = ProbeReferenceVolume.instance.MinBrickSize();
Vector3 tmpClamp = (bounds.size + new Vector3(minBrickSize, minBrickSize, minBrickSize));
tmpClamp.x = Mathf.Max(0f, tmpClamp.x);
tmpClamp.y = Mathf.Max(0f, tmpClamp.y);
tmpClamp.z = Mathf.Max(0f, tmpClamp.z);
serialized.size.vector3Value = tmpClamp;
}
}
static void Drawer_VolumeContent(SerializedProbeVolume serialized, Editor owner)
{
ProbeVolume pv = (serialized.serializedObject.targetObject as ProbeVolume);
bool hasProfile = (ProbeReferenceVolume.instance.sceneData?.GetProfileForScene(pv.gameObject.scene) != null);
EditorGUI.BeginChangeCheck();
if (pv.mightNeedRebaking)
{
var helpBoxRect = GUILayoutUtility.GetRect(new GUIContent(Styles.s_ProbeVolumeChangedMessage, EditorGUIUtility.IconContent("Warning@2x").image), EditorStyles.helpBox);
EditorGUI.HelpBox(helpBoxRect, Styles.s_ProbeVolumeChangedMessage, MessageType.Warning);
}
EditorGUILayout.PropertyField(serialized.globalVolume, Styles.s_GlobalVolume);
if (!serialized.globalVolume.boolValue)
{
EditorGUILayout.PropertyField(serialized.size, Styles.s_Size);
}
if (!hasProfile)
{
EditorGUILayout.HelpBox("No profile information is set for the scene that owns this probe volume so no subdivision information can be retrieved.", MessageType.Warning);
}
EditorGUI.BeginDisabledGroup(!hasProfile);
var rect = EditorGUILayout.GetControlRect(true);
EditorGUI.BeginProperty(rect, Styles.s_HighestSubdivLevel, serialized.highestSubdivisionLevelOverride);
EditorGUI.BeginProperty(rect, Styles.s_LowestSubdivLevel, serialized.lowestSubdivisionLevelOverride);
// Round min and max subdiv
int maxSubdiv = ProbeReferenceVolume.instance.GetMaxSubdivision() - 1;
if (ProbeReferenceVolume.instance.sceneData != null)
{
var profile = ProbeReferenceVolume.instance.sceneData.GetProfileForScene(pv.gameObject.scene);
if (profile != null)
{
ProbeReferenceVolume.instance.SetMinBrickAndMaxSubdiv(profile.minBrickSize, profile.maxSubdivision);
maxSubdiv = ProbeReferenceVolume.instance.GetMaxSubdivision() - 1;
}
else
{
maxSubdiv = Mathf.Max(0, maxSubdiv);
}
}
EditorGUILayout.LabelField("Subdivision Overrides", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serialized.overridesSubdivision, Styles.s_OverridesSubdivision);
EditorGUI.BeginDisabledGroup(!serialized.overridesSubdivision.boolValue);
int value = serialized.highestSubdivisionLevelOverride.intValue;
// We were initialized, but we cannot know the highest subdiv statically, so we need to resort to this.
if (serialized.highestSubdivisionLevelOverride.intValue < 0)
{
serialized.highestSubdivisionLevelOverride.intValue = maxSubdiv;
}
using (new EditorGUI.IndentLevelScope())
{
serialized.highestSubdivisionLevelOverride.intValue = Mathf.Min(maxSubdiv, EditorGUILayout.IntSlider(Styles.s_HighestSubdivLevel, serialized.highestSubdivisionLevelOverride.intValue, 0, maxSubdiv));
serialized.lowestSubdivisionLevelOverride.intValue = Mathf.Min(maxSubdiv, EditorGUILayout.IntSlider(Styles.s_LowestSubdivLevel, serialized.lowestSubdivisionLevelOverride.intValue, 0, maxSubdiv));
serialized.lowestSubdivisionLevelOverride.intValue = Mathf.Min(serialized.lowestSubdivisionLevelOverride.intValue, serialized.highestSubdivisionLevelOverride.intValue);
}
EditorGUI.EndProperty();
EditorGUI.EndProperty();
int minSubdivInVolume = serialized.overridesSubdivision.boolValue ? serialized.lowestSubdivisionLevelOverride.intValue : 0;
int maxSubdivInVolume = serialized.overridesSubdivision.boolValue ? serialized.highestSubdivisionLevelOverride.intValue : maxSubdiv;
EditorGUI.indentLevel--;
if (hasProfile)
{
EditorGUILayout.HelpBox($"The distance between probes will fluctuate between : {ProbeReferenceVolume.instance.GetDistanceBetweenProbes(maxSubdiv - maxSubdivInVolume)}m and {ProbeReferenceVolume.instance.GetDistanceBetweenProbes(maxSubdiv - minSubdivInVolume)}m", MessageType.Info);
}
EditorGUI.EndDisabledGroup();
EditorGUI.EndDisabledGroup();
if (EditorGUI.EndChangeCheck())
{
Vector3 tmpClamp = serialized.size.vector3Value;
tmpClamp.x = Mathf.Max(0f, tmpClamp.x);
tmpClamp.y = Mathf.Max(0f, tmpClamp.y);
tmpClamp.z = Mathf.Max(0f, tmpClamp.z);
serialized.size.vector3Value = tmpClamp;
}
EditorGUILayout.LabelField("Geometry Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(serialized.overrideRendererFilters, Styles.s_OverrideRendererFilters);
if (serialized.overrideRendererFilters.boolValue)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(serialized.objectLayerMask, Styles.s_ObjectLayerMask);
EditorGUILayout.PropertyField(serialized.minRendererVolumeSize, Styles.s_MinRendererVolumeSize);
EditorGUI.indentLevel--;
}
}
protected void OnSceneGUI()
{
ProbeVolume probeVolume = target as ProbeVolume;
if (Event.current.type == EventType.Layout)
{
probeVolume.DrawSelectedProbes();
}
if (!blendBoxes.TryGetValue(probeVolume, out HierarchicalBox blendBox))
{
return;
}
if (!shapeBoxes.TryGetValue(probeVolume, out HierarchicalBox shapeBox))
{
return;
}
switch (EditMode.editMode)
{
case k_EditBlend:
using (new Handles.DrawingScope(Matrix4x4.TRS(probeVolume.transform.position, probeVolume.transform.rotation, Vector3.one)))
{
//contained must be initialized in all case
shapeBox.center = Vector3.zero;
shapeBox.size = probeVolume.parameters.size;
blendBox.monoHandle = !probeVolume.parameters.advancedFade;
blendBox.center = CenterBlendLocalPosition(probeVolume);
blendBox.size = BlendSize(probeVolume);
EditorGUI.BeginChangeCheck();
blendBox.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(probeVolume, "Change Probe Volume Blend");
//work in local space to compute the change on positiveFade and negativeFade
Vector3 newCenterBlendLocalPosition = blendBox.center;
Vector3 halfSize = blendBox.size * 0.5f;
Vector3 size = probeVolume.parameters.size;
Vector3 posFade = newCenterBlendLocalPosition + halfSize;
posFade.x = 0.5f - posFade.x / size.x;
posFade.y = 0.5f - posFade.y / size.y;
posFade.z = 0.5f - posFade.z / size.z;
Vector3 negFade = newCenterBlendLocalPosition - halfSize;
negFade.x = 0.5f + negFade.x / size.x;
negFade.y = 0.5f + negFade.y / size.y;
negFade.z = 0.5f + negFade.z / size.z;
probeVolume.parameters.positiveFade = posFade;
probeVolume.parameters.negativeFade = negFade;
}
}
break;
case k_EditShape:
//important: if the origin of the handle's space move along the handle,
//handles displacement will appears as moving two time faster.
using (new Handles.DrawingScope(Matrix4x4.TRS(Vector3.zero, probeVolume.transform.rotation, Vector3.one)))
{
//contained must be initialized in all case
shapeBox.center = Quaternion.Inverse(probeVolume.transform.rotation) * probeVolume.transform.position;
shapeBox.size = probeVolume.parameters.size;
shapeBox.monoHandle = !probeVolume.parameters.advancedFade;
EditorGUI.BeginChangeCheck();
shapeBox.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(new Object[] { probeVolume, probeVolume.transform }, "Change Probe Volume Bounding Box");
probeVolume.parameters.size = shapeBox.size;
Vector3 delta = probeVolume.transform.rotation * shapeBox.center - probeVolume.transform.position;
probeVolume.transform.position += delta;;
}
}
break;
}
}
