void DrawRenderingSettings()
{
m_RenderingSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_RenderingSettingsFoldout.value, Styles.renderingSettingsText);
if (m_RenderingSettingsFoldout.value)
{
DrawRenderer();
var selectedCameraType = (CameraRenderType)m_AdditionalCameraDataCameraTypeProp.intValue;
if (selectedCameraType == CameraRenderType.Base)
{
DrawPostProcessing();
}
if (selectedCameraType == CameraRenderType.Overlay)
{
EditorGUILayout.PropertyField(m_AdditionalCameraClearDepth, Styles.clearDepth);
m_AdditionalCameraDataSO.ApplyModifiedProperties();
}
DrawOpaqueTexture();
DrawDepthTexture();
DrawRenderShadows();
if (selectedCameraType == CameraRenderType.Base)
{
DrawPriority();
}
settings.DrawCullingMask();
settings.DrawOcclusionCulling();
EditorGUILayout.Space();
EditorGUILayout.Space();
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
private void Settings()
{
settingsFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(settingsFoldout, "Settings");
if (!settingsFoldout)
{
EditorGUILayout.EndFoldoutHeaderGroup();
return;
}
EditorGUI.indentLevel++;
double maximumTimeBetweenTriggers;
EditorGUILayout.LabelField(new GUIContent("Maximum Time Between Triggers", "If two triggers are further apart than this time, the system will not count it towards you working on the game. Default = 5 minutes, take a look at the mean time between triggers and add something extra"));
if (Double.TryParse(EditorGUILayout.TextField("Minutes: ", TimeTracker.Settings.MaximumMinutesBetweenTriggers.ToString()), out maximumTimeBetweenTriggers))
{
if (maximumTimeBetweenTriggers != TimeTracker.Settings.MaximumMinutesBetweenTriggers)
{
TimeTracker.Settings.MaximumMinutesBetweenTriggers = maximumTimeBetweenTriggers;
TimeTracker.SaveSettings();
}
}
EditorGUI.indentLevel--;
EditorGUILayout.EndFoldoutHeaderGroup();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
serializedObject.Update();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_NeedHead);
EditorGUILayout.PropertyField(m_HeadHeight);
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_ListColumns);
EditorGUILayout.PropertyField(m_CellSize);
EditorGUILayout.PropertyField(m_CellSpace);
EditorGUILayout.PropertyField(m_ListPadding, true);
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_ContentSpacing);
EditorGUILayout.PropertyField(m_ContentPadding, true);
EditorGUILayout.EndFoldoutHeaderGroup();
serializedObject.ApplyModifiedProperties();
}
void DrawOutputSettings()
{
m_OutputSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_OutputSettingsFoldout.value, Styles.outputSettingsText);
if (m_OutputSettingsFoldout.value)
{
DrawTargetTexture();
if (camera.targetTexture == null)
{
DrawHDR();
DrawMSAA();
settings.DrawNormalizedViewPort();
settings.DrawDynamicResolution();
settings.DrawMultiDisplay();
}
// Third option comes later.
EditorGUILayout.Space();
EditorGUILayout.Space();
DrawVRSettings();
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
void DisplayAssetGroup(AssetGroupViewData group, GUIContent label, string statusMessage, MessageType status)
{
if (group.Expanded = EditorGUILayout.BeginFoldoutHeaderGroup(group.Expanded, label))
{
++EditorGUI.indentLevel;
if (!string.IsNullOrEmpty(statusMessage))
{
EditorGUILayout.HelpBox(statusMessage, status);
}
foreach (var path in group.AssetPathsAndStatuses)
{
var rowRect = EditorGUI.IndentedRect(
EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight)
);
s_TempContent.text = path.Key;
s_TempContent.tooltip = path.Value;
GUI.Label(new Rect(rowRect)
{
xMax = rowRect.xMax - Styles.FindAssetButtonWidth
}, s_TempContent);
if (
GUI.Button(new Rect(rowRect)
{
xMin = rowRect.xMax - Styles.FindAssetButtonWidth
}, Content.FindAsset)
)
{
EditorGUIUtility.PingObject(AssetDatabase.LoadMainAssetAtPath(path.Key));
}
}
--EditorGUI.indentLevel;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
static void DrawGroup <T>(List <T> list, GUIContent foldContent, GUIContent[] contents,
bool[] foldStates, ref bool topFoldState, Action <T> drawSingle)
{
if (list.Count == 0)
{
return;
}
topFoldState = EditorGUILayout.Foldout(topFoldState, foldContent);
if (!topFoldState)
{
return;
}
using (new EditorGUI.IndentLevelScope())
{
for (var i = 0; i < list.Count; i++)
{
var foldoutState = foldStates[i];
foldoutState = EditorGUILayout.BeginFoldoutHeaderGroup(foldoutState,
contents[i]);
foldStates[i] = foldoutState;
if (!foldoutState)
{
EditorGUILayout.EndFoldoutHeaderGroup();
continue;
}
drawSingle(list[i]);
EditorGUILayout.EndFoldoutHeaderGroup();
}
}
EditorGUILayout.Separator();
}
private void DrawRendering()
{
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
GUILayout.Space(-5f);
m_RenderingOptionsFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(m_RenderingOptionsFoldout, new GUIContent("Rendering"));
if (m_RenderingOptionsFoldout)
{
EditorGUI.indentLevel++;
var cullingMode = (int)culling.floatValue;
cullingMode = EditorGUILayout.Popup("Culling", cullingMode, new string[] { "Double-sided", "Front-faces", "Back-faces" });
culling.floatValue = cullingMode;
materialEditor.ShaderProperty(disableShadows, "Receive Shadows");
materialEditor.ShaderProperty(alphaToCoverage, new GUIContent("Alpha to coverage", "Reduces aliasing when using MSAA"));
if (alphaToCoverage.floatValue > 0 && UniversalRenderPipeline.asset.msaaSampleCount == 1)
{
EditorGUILayout.HelpBox("MSAA is disabled, alpha to coverage will have no effect", MessageType.None);
}
enableDistFade = EditorGUILayout.Toggle(new GUIContent("Distance fading", "Reduces the alpha clipping based on camera distance." +
"\n\nNote that this does not improve performance, only pixels are being hidden, meshes are still being rendered, " +
"best to match these settings to your maximum grass draw distance"), enableDistFade);
if (enableDistFade)
{
EditorGUI.indentLevel++;
DrawMinMaxSlider("Start/End", ref fadeStartDist, ref fadeEndDist);
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
}
void OnGUIInfo(Rect size)
{
GUILayout.BeginArea(size);
Info = EditorGUILayout.BeginFoldoutHeaderGroup(Info, "Info");
if (Info)
{
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
if (Selection.gameObjects != null)
{
foreach (var k in Selection.gameObjects)
{
Hex cell = k.gameObject.GetComponent <Hex>();
if (cell)
{
MapCellTool.Draw(cell);
}
HexBuilding build = k.gameObject.GetComponent <HexBuilding>();
if (build)
{
if (build.hex)
{
GUI.color = Color.red;
EditorGUILayout.LabelField("选中了建筑");
GUI.color = Color.white;
MapCellTool.Draw(build.hex);
}
}
}
}
EditorGUILayout.EndScrollView();
}
EditorGUILayout.EndFoldoutHeaderGroup();
GUILayout.EndArea();
}
private void GUISyncing()
{
if (hiveType != HiveType.Remote && behaviourType != SpecialBehaviourType.MirrorManager)
{
headerSync = EditorGUILayout.BeginFoldoutHeaderGroup(headerSync, "Syncing", headerStyle);
if (headerSync)
{
EditorGUI.BeginChangeCheck();
synced = EditorGUILayout.Toggle("Is Synced", action.is_synced);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(action, "Modify Syncing");
action.is_synced = synced;
}
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
else
{
action.is_synced = false;
}
}
void DrawOutputSettings()
{
m_OutputSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_OutputSettingsFoldout.value, Styles.outputSettingsText);
if (m_OutputSettingsFoldout.value)
{
var selectedCameraType = (CameraRenderType)m_AdditionalCameraDataCameraTypeProp.intValue;
if (selectedCameraType == CameraRenderType.Base)
{
DrawHDR();
DrawMSAA();
settings.DrawNormalizedViewPort();
settings.DrawDynamicResolution();
settings.DrawMultiDisplay();
}
else if (selectedCameraType == CameraRenderType.Offscreen)
{
DrawTargetTexture();
}
EditorGUILayout.Space();
EditorGUILayout.Space();
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
public override void OnInspectorGUI()
{
if (HasErrors())
{
return;
}
BeginEditing();
OnPreInspectorGUI();
PropertyField(_thresholdProperty, "Hit Threshold");
OnTargetInspectorGUI();
// physics material
if (_foldoutMaterial = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutMaterial, "Physics Material"))
{
EditorGUI.BeginDisabledGroup(_overwritePhysicsProperty.boolValue);
PropertyField(_physicsMaterialProperty, "Preset");
EditorGUI.EndDisabledGroup();
PropertyField(_overwritePhysicsProperty);
EditorGUI.BeginDisabledGroup(!_overwritePhysicsProperty.boolValue);
PropertyField(_elasticityProperty);
PropertyField(_elasticityFalloffProperty);
PropertyField(_frictionProperty);
PropertyField(_scatterProperty, "Scatter Angle");
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndFoldoutHeaderGroup();
base.OnInspectorGUI();
EndEditing();
}
void DrawPreviewControls()
{
GUIStyle foldoutStyle = EditorStyles.foldout;
foldoutStyle.fontStyle = FontStyle.Bold;
// Preview settings.
GUILayout.Space(5);
previewSettingsFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(previewSettingsFoldout, "Preview settings", foldoutStyle);
if (previewSettingsFoldout)
{
EditorGUI.indentLevel++;
previewType = (PreviewType)EditorGUILayout.EnumPopup("Preview type", previewType);
EditorGUI.indentLevel++;
if (currentWindowTab == 0)
{
textureModule.DrawPreviewControls(previewType);
}
else
{
toolsModule.DrawPreviewControls(previewType);
}
EditorGUI.indentLevel--;
previewMode = (PreviewMode)EditorGUILayout.Popup("Live preview", (int)previewMode, previewModeStrings);
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
GUILayout.Space(5);
}
public override void OnInspectorGUI()
{
if (target is MeshGenerator meshGenerator && meshGenerator.Field is ScalarField scalarField)
{
using (var changeCheckScope = new EditorGUI.ChangeCheckScope()) {
var size = EditorGUILayout.Vector3IntField("Size", meshGenerator.size).ToSize();
var step = EditorGUILayout.Vector3Field("Step", meshGenerator.step).ToSize();
var isoLevel = Mathf.Clamp01(EditorGUILayout.Slider("IsoLevel", meshGenerator.isoLevel, 0, 1));
if (changeCheckScope.changed)
{
meshGenerator.Generate();
Undo.RecordObject(target, "Change Fields");
meshGenerator.size = size;
meshGenerator.step = step;
meshGenerator.isoLevel = isoLevel;
}
}
using (var changeCheckScope = new EditorGUI.ChangeCheckScope()) {
_isFieldsExpanded = EditorGUILayout.BeginFoldoutHeaderGroup(_isFieldsExpanded, "Fields");
if (_isFieldsExpanded)
{
FieldEditorGUI.InvokeGUI(scalarField);
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (changeCheckScope.changed)
{
meshGenerator.Generate();
}
}
}
}
void DrawShadowSettings()
{
m_ShadowSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_ShadowSettingsFoldout.value, Styles.shadowSettingsText);
if (m_ShadowSettingsFoldout.value)
{
EditorGUI.indentLevel++;
m_ShadowDistanceProp.floatValue = Mathf.Max(0.0f, EditorGUILayout.FloatField(Styles.shadowDistanceText, m_ShadowDistanceProp.floatValue));
CoreEditorUtils.DrawPopup(Styles.shadowCascadesText, m_ShadowCascadesProp, Styles.shadowCascadeOptions);
ShadowCascadesOption cascades = (ShadowCascadesOption)m_ShadowCascadesProp.intValue;
if (cascades == ShadowCascadesOption.FourCascades)
LightweightRenderPipelineEditorUtils.DrawCascadeSplitGUI<Vector3>(ref m_ShadowCascade4SplitProp);
else if (cascades == ShadowCascadesOption.TwoCascades)
LightweightRenderPipelineEditorUtils.DrawCascadeSplitGUI<float>(ref m_ShadowCascade2SplitProp);
m_ShadowDepthBiasProp.floatValue = EditorGUILayout.Slider(Styles.shadowDepthBias, m_ShadowDepthBiasProp.floatValue, 0.0f, LightweightRenderPipeline.maxShadowBias);
m_ShadowNormalBiasProp.floatValue = EditorGUILayout.Slider(Styles.shadowNormalBias, m_ShadowNormalBiasProp.floatValue, 0.0f, LightweightRenderPipeline.maxShadowBias);
EditorGUILayout.PropertyField(m_SoftShadowsSupportedProp, Styles.supportsSoftShadows);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.Space();
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
void DrawAdvancedSettings()
{
m_AdvancedSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_AdvancedSettingsFoldout.value, Styles.advancedSettingsText);
if (m_AdvancedSettingsFoldout.value)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_SRPBatcher, Styles.srpBatcher);
EditorGUILayout.PropertyField(m_SupportsDynamicBatching, Styles.dynamicBatching);
EditorGUILayout.PropertyField(m_MixedLightingSupportedProp, Styles.mixedLightingSupportLabel);
EditorGUILayout.PropertyField(m_ShaderVariantLogLevel, Styles.shaderVariantLogLevel);
if (m_ShaderVariantLogLevel.enumValueIndex == (int)ShaderVariantLogLevel.ShowIfAbove)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_ShaderVariantShowNumProp, Styles.shaderVariantNumberLabel);
EditorGUI.indentLevel--;
}
EditorGUILayout.PropertyField(m_killShaderVariantsAssetProp);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.Space();
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
var editable = target as IItemMainAuthoring;
var dragPointEditable = target as IDragPointsEditable;
if (editable == null || dragPointEditable == null)
{
return;
}
var editButtonText = dragPointEditable.DragPointEditEnabled ? "Stop Editing Drag Points" : "Edit Drag Points";
if (GUILayout.Button(editButtonText))
{
dragPointEditable.DragPointEditEnabled = !dragPointEditable.DragPointEditEnabled;
SceneView.RepaintAll();
}
if (dragPointEditable.DragPointEditEnabled)
{
if (editable.IsLocked)
{
EditorGUILayout.LabelField("Drag Points are Locked");
}
else
{
_foldoutControlPoints = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutControlPoints, "Drag Points");
if (_foldoutControlPoints)
{
EditorGUI.indentLevel++;
for (var i = 0; i < DragPointsHandler.ControlPoints.Count; ++i)
{
var controlPoint = DragPointsHandler.ControlPoints[i];
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField($"#{i} ({controlPoint.DragPoint.Center.X},{controlPoint.DragPoint.Center.Y},{controlPoint.DragPoint.Center.Z})");
if (GUILayout.Button("Copy"))
{
CopyDragPoint(controlPoint.ControlId);
}
else if (GUILayout.Button("Paste"))
{
PasteDragPoint(controlPoint.ControlId);
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel++;
if (HasDragPointExposure(DragPointExposure.SlingShot))
{
ItemDataField("Slingshot", ref controlPoint.DragPoint.IsSlingshot);
}
if (HasDragPointExposure(DragPointExposure.Smooth))
{
ItemDataField("Smooth", ref controlPoint.DragPoint.IsSmooth);
}
if (HasDragPointExposure(DragPointExposure.Texture))
{
ItemDataField("Has AutoTexture", ref controlPoint.DragPoint.HasAutoTexture);
ItemDataSlider("Texture Coord", ref controlPoint.DragPoint.TextureCoord, 0.0f, 1.0f);
}
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
}
}
public override void OnGUI(MaterialEditor editor, MaterialProperty[] properties)
{
GUILayout.BeginHorizontal();
GUILayout.Label(Resources.Load <Texture>("TOON_WATER_LOGO"), GUILayout.Width(308), GUILayout.Height(244));
GUILayout.EndHorizontal();
//WATER COLORS
colorsFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(colorsFoldout, "Water Colors");
if (colorsFoldout)
{
MaterialProperty waterDepth = FindProperty(WATER_DEPTH_ID, properties);
editor.FloatProperty(waterDepth, "Water Depth");
MaterialProperty shallowColor = FindProperty(SHALLOW_WATER_COLOR_ID, properties);
editor.ColorProperty(shallowColor, "Shallow Water Color");
MaterialProperty deepColor = FindProperty(DEEP_WATER_COLOR_ID, properties);
editor.ColorProperty(deepColor, "Deep Water Color");
}
EditorGUILayout.EndFoldoutHeaderGroup();
//LIGHTNING
lightningFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(lightningFoldout, "Light settings");
if (lightningFoldout)
{
MaterialProperty specularPower = FindProperty(SPECULAR_ID, properties);
editor.RangeProperty(specularPower, "Specular Power");
MaterialProperty specularCutoff = FindProperty(SPECULAR_CUTOFF_ID, properties);
editor.RangeProperty(specularCutoff, "Specular Cutoff");
MaterialProperty specularEdgesSmoothnessFactor = FindProperty(SPECULAR_EDGES_SMOOTHNESS_FACTOR_ID, properties);
editor.RangeProperty(specularEdgesSmoothnessFactor, "Specular Edges Smoothness Factor");
MaterialProperty specularColor = FindProperty(SPECULAR_COLOR_ID, properties);
editor.ColorProperty(specularColor, "Specular Color");
MaterialProperty normalsStrenght = FindProperty(NORMALS_STRENGTH_ID, properties);
editor.FloatProperty(normalsStrenght, "Normals Strength");
}
EditorGUILayout.EndFoldoutHeaderGroup();
//FRESNEL
fresnelFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(fresnelFoldout, "Fresnel");
if (fresnelFoldout)
{
MaterialProperty fresnelPower = FindProperty(FRESNEL_POWER_ID, properties);
editor.RangeProperty(fresnelPower, "Fresnel Power");
if (fresnelPower.floatValue <= 0)
{
EditorGUILayout.HelpBox("When Fresnel Power is set to 0 effect is disabled and Planar Reflections will not be visible!", MessageType.Info);
}
}
EditorGUILayout.EndFoldoutHeaderGroup();
//REFRACTION
refractionFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(refractionFoldout, "Refraction");
if (refractionFoldout)
{
MaterialProperty refractionStrenght = FindProperty(REFRACTION_STRENGTH_ID, properties);
editor.RangeProperty(refractionStrenght, "Refraction Strength");
MaterialProperty useRefraction = FindProperty(USE_REFRACTION_IN_DEPTH_BASED_WATER_COLOR, properties);
useRefraction.floatValue = EditorGUILayout.Toggle("Use Refraction In Depth Based Water Color", useRefraction.floatValue > 0) ? 1 : 0;
}
EditorGUILayout.EndFoldoutHeaderGroup();
//REFLECTION
reflectionFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(reflectionFoldout, "Planar Reflections");
if (reflectionFoldout)
{
MaterialProperty reflectionVisiblity = FindProperty(REFLECTION_VISIBILITY_ID, properties);
editor.RangeProperty(reflectionVisiblity, "Reflection Visibility");
MaterialProperty reflectionDistortion = FindProperty(REFLECTION_DISTORTION_STRENGHT, properties);
editor.RangeProperty(reflectionDistortion, "Reflection Distortion Strenght");
}
EditorGUILayout.EndFoldoutHeaderGroup();
//FOAM
foamFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(foamFoldout, "Foam");
if (foamFoldout)
{
MaterialProperty foamColor = FindProperty(FOAM_COLOR_ID, properties);
editor.ColorProperty(foamColor, "Foam Color");
MaterialProperty foamAmount = FindProperty(FOAM_AMOUNT_ID, properties);
editor.FloatProperty(foamAmount, "Foam Amount");
MaterialProperty foamCutoff = FindProperty(FOAM_CUTOFF_ID, properties);
editor.FloatProperty(foamCutoff, "Foam Cutoff");
MaterialProperty foamDirection = FindProperty(FOAM_DIRECTION_ID, properties);
editor.VectorProperty(foamDirection, "Foam Direction");
MaterialProperty foamScale = FindProperty(FOAM_SCALE_ID, properties);
editor.VectorProperty(foamScale, "Foam Scale");
}
EditorGUILayout.EndFoldoutHeaderGroup();
//WAVES
wavesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(wavesFoldout, "Waves");
if (wavesFoldout)
{
MaterialProperty waveDir = FindProperty(WAVE_DIRECTION_ID, properties);
editor.VectorProperty(waveDir, "Wave Direction");
MaterialProperty waveSize = FindProperty(WAVE_SIZE_ID, properties);
editor.VectorProperty(waveSize, "Wave Size");
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
protected void OnGUI()
{
if (m_Settings == null)
{
m_Settings = CreateInstance <SdfBakerSettings>();
m_Settings.name = "None";
}
bool needsUpdate = false;
Undo.RecordObject(this, "Settings Asset change");
Undo.RecordObject(m_Settings, "SDF Baker Parameter change");
GUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
var newSettings = (SdfBakerSettings)EditorGUILayout.ObjectField(Contents.settingsAsset, m_Settings, typeof(SdfBakerSettings), true, GUILayout.MinWidth(20),
GUILayout.MaxWidth(400), GUILayout.ExpandWidth(true));
if (EditorGUI.EndChangeCheck())
{
if (newSettings != null)
{
LoadSettings(newSettings);
}
else
{
CreateNewSession();
}
}
GUILayout.Space(5);
GUI.enabled = EditorUtility.IsDirty(m_Settings);
if (GUILayout.Button(Contents.saveSettings, GUILayout.MinWidth(20), GUILayout.ExpandWidth(true)))
{
SaveSettings();
}
GUI.enabled = true;
DrawContextIcon();
GUILayout.EndHorizontal();
GUILayout.Space(5);
EditorGUI.BeginChangeCheck();
maxResolution = Mathf.Clamp(EditorGUILayout.IntField(Contents.maxResolution, maxResolution), 8, 1024);
bool maxResChanged = EditorGUI.EndChangeCheck();
needsUpdate |= maxResChanged;
if (maxResolution > 255)
{
EditorGUILayout.HelpBox(
"Higher resolutions are more expensive to calculate and can make Unity unstable.",
MessageType.Warning);
}
EditorGUI.BeginChangeCheck();
var prevWideMode = EditorGUIUtility.wideMode;
EditorGUIUtility.wideMode = true;
boxCenter = EditorGUILayout.Vector3Field("Box Center", boxCenter);
needsUpdate |= EditorGUI.EndChangeCheck();
EditorGUI.BeginChangeCheck();
boxSizeReference = EditorGUILayout.Vector3Field(Contents.boxSizeReference, boxSizeReference);
bool boxSizeChanged = EditorGUI.EndChangeCheck();
needsUpdate |= boxSizeChanged;
if (boxSizeChanged || maxResChanged)
{
m_ActualBoxSize = SnapBoxToVoxels();
}
using (new EditorGUI.DisabledScope(true))
{
SerializedObject selfSO = new SerializedObject(this);
EditorGUILayout.PropertyField(selfSO.FindProperty("m_ActualBoxSize"), Contents.actualBoxSize);
}
if (boxSizeReference.x * boxSizeReference.y * boxSizeReference.z <= Single.Epsilon)
{
EditorGUILayout.HelpBox("The volume of your bounding box is zero.", MessageType.Warning);
}
int estimatedGridSize = EstimateGridSize();
if (estimatedGridSize > 1 << 21 || selectedMesh == null)
{
GUI.enabled = false;
m_LiveUpdate = false;
}
EditorGUI.BeginChangeCheck();
m_LiveUpdate = EditorGUILayout.Toggle(Contents.liveUpdate, m_LiveUpdate);
needsUpdate |= (EditorGUI.EndChangeCheck() & m_LiveUpdate);
GUI.enabled = true;
if (m_LiveUpdate)
{
EditorGUILayout.HelpBox(
"Baking the mesh in real-time might cause slowdowns or instabilities when the resolution and/or the sign passes count is high ",
MessageType.Warning);
}
bool fitPaddingChanged = false;
if (m_ShowAdvanced)
{
m_FoldOutParameters = EditorGUILayout.BeginFoldoutHeaderGroup(m_FoldOutParameters, Contents.bakingParameters);
EditorGUI.BeginChangeCheck();
if (m_FoldOutParameters)
{
EditorGUI.indentLevel++;
signPassesCount = Mathf.Clamp(EditorGUILayout.IntField(Contents.signPass, signPassesCount), 0,
20);
inOutThreshold = EditorGUILayout.Slider(Contents.inOutParam, inOutThreshold, 0.0f, 1.0f);
surfaceOffset = EditorGUILayout.Slider(Contents.sdfOffset, surfaceOffset, -0.5f, 0.5f);
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
needsUpdate |= EditorGUI.EndChangeCheck();
EditorGUI.BeginChangeCheck();
m_Settings.m_FitPaddingVoxel = EditorGUILayout.Vector3IntField(Contents.fitPadding, m_Settings.m_FitPaddingVoxel);
fitPaddingChanged = EditorGUI.EndChangeCheck();
}
EditorGUIUtility.wideMode = prevWideMode;
if (selectedMesh != null)
{
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
if (GUILayout.Button(Contents.fitBoxToMesh))
{
FitBoxToMesh();
}
needsUpdate |= EditorGUI.EndChangeCheck();
EditorGUI.BeginChangeCheck();
if (GUILayout.Button(Contents.fitCubeToMesh))
{
FitCubeToMesh();
}
needsUpdate |= EditorGUI.EndChangeCheck();
EditorGUILayout.EndHorizontal();
}
EditorGUI.BeginChangeCheck();
modelSource = (ModelSource)EditorGUILayout.EnumPopup(Contents.bakeSource, modelSource);
bool changedSource = EditorGUI.EndChangeCheck();
needsUpdate |= changedSource;
switch (modelSource)
{
case ModelSource.Mesh:
EditorGUI.BeginChangeCheck();
selectedMesh =
(Mesh)EditorGUILayout.ObjectField(Contents.mesh, selectedMesh, typeof(Mesh), false);
bool meshFieldHasChanged = EditorGUI.EndChangeCheck();
needsUpdate |= meshFieldHasChanged;
m_RefreshMeshPreview |= meshFieldHasChanged | changedSource;
if (m_RefreshMeshPreview)
{
m_Settings.ApplySelectedMesh();
}
break;
case ModelSource.MeshPrefab:
EditorGUI.BeginChangeCheck();
meshPrefab =
(GameObject)EditorGUILayout.ObjectField(Contents.meshPrefab, meshPrefab, typeof(GameObject),
false);
meshFieldHasChanged = EditorGUI.EndChangeCheck() || m_PrefabChanged;
m_PrefabChanged = false;
needsUpdate |= meshFieldHasChanged;
m_RefreshMeshPreview |= meshFieldHasChanged | changedSource || (mesh == null);
bool rebuildMesh = m_RefreshMeshPreview;
if (rebuildMesh)
{
m_Settings.BuildMeshFromPrefab();
rebuildMesh = false;
}
break;
}
if (mesh == null)
{
m_LiveUpdate = false;
}
if (m_RefreshMeshPreview && mesh != null)
{
FitBoxToMesh();
m_MeshPreview?.Dispose();
m_MeshPreview = new SdfBakerPreview(mesh);
m_RefreshMeshPreview = false;
}
if (mesh == null || (estimatedGridSize > UnityEngine.VFX.SDF.MeshToSDFBaker.kMaxGridSize) || InternalMeshUtil.GetPrimitiveCount(mesh) == 0)
{
GUI.enabled = false;
}
if (GUILayout.Button("Bake mesh") || m_LiveUpdate && needsUpdate)
{
if (m_Baker == null)
{
m_Baker = new MeshToSDFBaker(boxSizeReference, boxCenter, maxResolution, mesh, signPassesCount,
inOutThreshold, surfaceOffset);
}
else
{
m_Baker.Reinit(boxSizeReference, boxCenter, maxResolution, mesh, signPassesCount,
inOutThreshold, surfaceOffset);
}
m_Baker.BakeSDF();
m_BakedSDF = m_Baker.SdfTexture;
}
GUI.enabled = true;
bool canSave = true;
if ((m_BakedSDF == null) || (m_Baker == null))
{
canSave = false;
GUI.enabled = false;
}
if (GUILayout.Button(canSave ? Contents.saveSDF : Contents.saveSDFBlocked))
{
m_Baker.SaveToAsset();
}
GUI.enabled = true;
previewObject = (PreviewChoice)EditorGUILayout.EnumPopup(Contents.previewChoice, previewObject);
if ((previewObject & PreviewChoice.Mesh) != 0)
{
UpdateMeshPreview();
}
if ((previewObject & PreviewChoice.Texture) != 0)
{
UpdateTexture3dPreview();
}
if (needsUpdate)
{
EditorUtility.SetDirty(m_Settings);
}
}
public override void OnInspectorGUI()
{
AudioPlayerMusic myScript = (AudioPlayerMusic)target;
List <string> options = new List <string>();
System.Type enumType = null;
if (!AudioManager.instance)
{
EditorGUILayout.HelpBox("Could not find Audio Manager in the scene! This component needs AudioManager " +
"in order to function!", MessageType.Error);
}
else
{
enumType = AudioManager.instance.GetSceneMusicEnum();
if (enumType == null)
{
EditorGUILayout.HelpBox("Could not find Audio File info! Try regenerating Audio Files in AudioManager!", MessageType.Error);
}
else
{
foreach (string s in System.Enum.GetNames(enumType))
{
options.Add(s);
}
}
}
EditorGUILayout.LabelField("Specify Music to Play", EditorStyles.boldLabel);
GUIContent musicDesc = new GUIContent("Music", "Music that will be played");
int music = serializedObject.FindProperty("music").intValue;
using (new EditorGUI.DisabledScope(myScript.GetAttachedFile() != null))
{
serializedObject.FindProperty("music").intValue = EditorGUILayout.Popup(musicDesc, music, options.ToArray());
}
GUIContent fileText = new GUIContent("Custom AudioClip", "Overrides the \"Music\" parameter with an AudioClip if not null");
SerializedProperty customSound = serializedObject.FindProperty("musicFile");
EditorGUILayout.Space();
GUIContent fontent = new GUIContent("Custom AudioClip Settings", "These settings only apply if you input your own custom AudioClip rather than choosing from the generated Audio Library");
if (myScript.GetAttachedFile() == null)
{
showAudioClipSettings = EditorGUILayout.Foldout(showAudioClipSettings, fontent);
}
else
{
showAudioClipSettings = EditorGUILayout.BeginFoldoutHeaderGroup(showAudioClipSettings, fontent);
}
if (showAudioClipSettings)
{
EditorGUILayout.ObjectField(customSound, fileText);
using (new EditorGUI.DisabledScope(myScript.GetAttachedFile() == null))
{
DrawPropertiesExcluding(serializedObject, new[] { "m_Script", "musicFile", "playOnStart", "playOnEnable",
"stopOnDisable", "stopOnDestroy", "keepPlaybackPosition", "restartOnReplay", "musicFadeTime", "transitionMode" });
}
}
if (myScript.GetAttachedFile() != null)
{
EditorGUILayout.EndFoldoutHeaderGroup();
}
EditorGUILayout.Space();
GUIContent lontent = new GUIContent("Music Player Settings", "Modify settings specific to Audio Player Music");
EditorGUILayout.LabelField(lontent, EditorStyles.boldLabel);
EditorGUILayout.PropertyField(serializedObject.FindProperty("transitionMode"));
if (myScript.GetTransitionMode() != TransitionMode.None)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("keepPlaybackPosition"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("musicFadeTime"));
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("restartOnReplay"));
EditorGUILayout.Space();
EditorGUILayout.PropertyField(serializedObject.FindProperty("playOnStart"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("playOnEnable"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("stopOnDisable"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("stopOnDestroy"));
serializedObject.ApplyModifiedProperties();
EditorGUILayout.Space();
#region Quick Reference Guide
showHowTo = EditorGUILayout.BeginFoldoutHeaderGroup(showHowTo, "Quick Reference Guide");
if (showHowTo)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("Overview", EditorStyles.boldLabel);
EditorGUILayout.HelpBox(
"This component allows you to easily play music anywhere in the scene."
, MessageType.None);
EditorGUILayout.HelpBox(
"To get started, choose your music to play from the drop-down at the top. " +
"Make sure you've generated your Audio Libraries in your Audio Manager. "
, MessageType.None);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Tips", EditorStyles.boldLabel);
EditorGUILayout.HelpBox(
"Alternatively, you can specify to use your own AudioClip by filling in the AudioClip. " +
"You can then fill out the Custom AudioClip settings so the AudioPlayer plays your music to your liking."
, MessageType.None);
//EditorGUILayout.HelpBox(
// "AudioPlayer includes a public function Play() that lets you play the sound in AudioPlayer on your own. " +
// "AudioPlayer's Play() function also returns the AudioSource to let you further modify the audio being played."
// , MessageType.None);
}
EditorGUILayout.Space();
#endregion
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
try
{
EditorPersistantBoolVariable.Initialize(ref this.folded, EditorPersistantBoolVariable.BuildKeyFromObject(property.serializedObject.targetObject, property.name));
Inline byEnumProperty = (Inline)attribute;
EditorGUI.BeginChangeCheck();
string propertyName = "";
for (var i = 0; i < EditorGUI.indentLevel; i++)
{
propertyName += " ";
}
propertyName += property.name;
this.folded.SetValue(EditorGUILayout.BeginFoldoutHeaderGroup(this.folded.GetValue(), propertyName));
EditorGUILayout.EndFoldoutHeaderGroup();
if (EditorGUI.EndChangeCheck())
{
if (!this.folded.GetValue())
{
if (this.inlineEditor != null)
{
Editor.DestroyImmediate(inlineEditor);
this.inlineEditor = null;
}
}
}
if (this.folded.GetValue())
{
EditorGUI.indentLevel += 1;
EditorGUILayout.PropertyField(property);
EditorGUI.indentLevel -= 1;
if (property.propertyType == SerializedPropertyType.ObjectReference && property.objectReferenceValue != null)
{
if (this.inlineEditor == null)
{
inlineEditor = DynamicEditorCreation.Get().CreateEditor(property.objectReferenceValue);
}
if (this.inlineEditor != null)
{
EditorGUI.indentLevel += 1;
this.inlineEditor.OnInspectorGUI();
EditorGUI.indentLevel -= 1;
}
}
else
{
if (EditorUtility.IsPersistent(property.serializedObject.targetObject))
{
if (byEnumProperty.CreateAtSameLevelIfAbsent)
{
if (GUILayout.Button(new GUIContent("CREATE")))
{
var fieldType = SerializableObjectHelper.GetPropertyFieldInfo(property).FieldType;
if (fieldType.IsAbstract || fieldType.IsInterface)
{
//Open popup to select implementation
ClassSelectionEditorWindow.Show(Event.current.mousePosition, fieldType, (Type selectedType) =>
{
var createdAsset = AssetHelper.CreateAssetAtSameDirectoryLevel((ScriptableObject)property.serializedObject.targetObject, selectedType.Name, property.name);
property.objectReferenceValue = (Object)createdAsset;
});
}
else
{
var createdAsset = AssetHelper.CreateAssetAtSameDirectoryLevel((ScriptableObject)property.serializedObject.targetObject, property.type.Replace("PPtr<$", "").Replace(">", ""), property.name);
property.objectReferenceValue = (Object)createdAsset;
}
}
}
}
}
}
}
catch (Exception e)
{
}
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var lastSceneName = string.Empty;
var fieldLayoutOptions = new GUILayoutOption[]
{
GUILayout.Width(120f)
};
EditorGUILayout.BeginHorizontal();
GUILayout.Space(40);
EditorGUILayout.LabelField(new GUIContent("Scenes", "The scene to apply this filter to"), GUILayout.Width(180));
EditorGUILayout.LabelField(new GUIContent("Reason", "The reason this config is filtered"), fieldLayoutOptions);
EditorGUILayout.LabelField(new GUIContent("Color Space", "Color space to filter, Unitialized will filter all color spaces."), fieldLayoutOptions);
EditorGUILayout.LabelField(new GUIContent("Platform", "The build platform to filter, No Target will filter all platforms."), fieldLayoutOptions);
EditorGUILayout.LabelField(new GUIContent("Graphics API", "The graphics api to filter, Null filters all apis."), fieldLayoutOptions);
EditorGUILayout.LabelField(new GUIContent("XR SDK", "Which XR platform to filter, use the same string as found in the VR SDK options. Blank will filter all (including non-xr configs) and None will filter only non-vr configs."), fieldLayoutOptions);
EditorGUILayout.LabelField(new GUIContent("Stereo Rendering Mode", "Stereo rendering mode to filter, mp for Multi Pass, sp for Single Pass and spi for Instancing."), GUILayout.MinWidth(120));
EditorGUILayout.EndHorizontal();
for (int i = 0; i < filters.arraySize; i++)
{
var filterElement = filters.GetArrayElementAtIndex(i);
var scene = filterElement.FindPropertyRelative("FilteredScene");
var scenes = filterElement.FindPropertyRelative("FilteredScenes");
var colorSpace = filterElement.FindPropertyRelative("ColorSpace");
var buildPlatform = filterElement.FindPropertyRelative("BuildPlatform");
var graphicsType = filterElement.FindPropertyRelative("GraphicsDevice");
var xrsdk = filterElement.FindPropertyRelative("XrSdk");
var stereoModes = filterElement.FindPropertyRelative("StereoModes");
var reason = filterElement.FindPropertyRelative("Reason");
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("del", GUILayout.Width(40)))
{
filters.DeleteArrayElementAtIndex(i);
continue;
}
// This is here to convert old test filters which did not have the scenes in
// an array to be converted to the new data structure.
if (scene.objectReferenceValue != null)
{
scenes.arraySize += 1;
scenes.FindPropertyRelative(
"Array.data[" + (scenes.arraySize - 1) + "]").objectReferenceValue = scene.objectReferenceValue;
scene.objectReferenceValue = null;
}
EditorGUILayout.PropertyField(scenes.FindPropertyRelative("Array.size"), GUIContent.none, GUILayout.Width(40));
if (scenes.arraySize > 1)
{
// This little space is needed so the foldout carrot doesn't overlap the previous field.
GUILayout.Space(10);
EditorGUILayout.BeginVertical(GUILayout.Width(110));
EditorGUILayout.BeginFoldoutHeaderGroup(true, "Filtered Scenes");
for (int j = 0; j < scenes.arraySize; j++)
{
var singleScene = scenes.FindPropertyRelative(string.Format("Array.data[{0}]", j));
EditorGUILayout.PropertyField(singleScene, GUIContent.none, GUILayout.Width(110));
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndFoldoutHeaderGroup();
}
else if (scenes.arraySize == 1)
{
var singleScene = scenes.FindPropertyRelative("Array.data[0]");
EditorGUILayout.PropertyField(singleScene, GUIContent.none, fieldLayoutOptions);
}
EditorGUILayout.PropertyField(reason, GUIContent.none, fieldLayoutOptions);
EditorGUILayout.PropertyField(colorSpace, GUIContent.none, fieldLayoutOptions);
EditorGUILayout.PropertyField(buildPlatform, GUIContent.none, fieldLayoutOptions);
EditorGUILayout.PropertyField(graphicsType, GUIContent.none, fieldLayoutOptions);
EditorGUILayout.PropertyField(xrsdk, GUIContent.none, fieldLayoutOptions);
if (EditorGUILayout.ToggleLeft("mp",
((StereoRenderingModeFlags)stereoModes.intValue & StereoRenderingModeFlags.MultiPass) == StereoRenderingModeFlags.MultiPass,
GUILayout.MaxWidth(40)))
{
stereoModes.intValue |= (int)StereoRenderingModeFlags.MultiPass;
}
else
{
stereoModes.intValue &= ~(int)StereoRenderingModeFlags.MultiPass;
}
if (EditorGUILayout.ToggleLeft("sp",
((StereoRenderingModeFlags)stereoModes.intValue & StereoRenderingModeFlags.SinglePass) == StereoRenderingModeFlags.SinglePass,
GUILayout.MaxWidth(40)))
{
stereoModes.intValue |= (int)StereoRenderingModeFlags.SinglePass;
}
else
{
stereoModes.intValue &= ~(int)StereoRenderingModeFlags.SinglePass;
}
if (EditorGUILayout.ToggleLeft("spi",
((StereoRenderingModeFlags)stereoModes.intValue & StereoRenderingModeFlags.Instancing) == StereoRenderingModeFlags.Instancing,
GUILayout.MaxWidth(40)))
{
stereoModes.intValue |= (int)StereoRenderingModeFlags.Instancing;
}
else
{
stereoModes.intValue &= ~(int)StereoRenderingModeFlags.Instancing;
}
EditorGUILayout.EndHorizontal();
}
if (GUILayout.Button(new GUIContent("New Filter", "Add new filter")))
{
filters.arraySize += 1;
var lastFilter = filters.GetArrayElementAtIndex(filters.arraySize - 1);
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"FilteredScenes").arraySize = 1;
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"FilteredScenes").GetArrayElementAtIndex(0).objectReferenceValue = null;
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"Reason").stringValue = "";
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"XrSdk").stringValue = "";
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"ColorSpace").intValue = (int)ColorSpace.Uninitialized;
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"BuildPlatform").intValue = (int)BuildTarget.NoTarget;
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"GraphicsDevice").intValue = (int)GraphicsDeviceType.Null;
lastFilter.serializedObject.FindProperty("filters.Array.data[" + (filters.arraySize - 1) + "]." +
"StereoModes").intValue = (int)StereoRenderingModeFlags.None;
}
serializedObject.ApplyModifiedProperties();
if (GUILayout.Button(new GUIContent("Sort", "Sort filters by scene name.")))
{
var filterObjectPath = AssetDatabase.GetAssetPath(target.GetInstanceID());
var filterObject = AssetDatabase.LoadAssetAtPath <TestFilters>(filterObjectPath);
filterObject.SortBySceneName();
EditorUtility.SetDirty(filterObject);
AssetDatabase.SaveAssets();
}
}
public override void OnInspectorGUI()
{
ButtonIconSet bis = (ButtonIconSet)target;
bool showQuadIconFoldout = SessionState.GetBool(ShowQuadIconsFoldoutKey, false);
bool showSpriteIconFoldout = SessionState.GetBool(ShowSpriteIconsFoldoutKey, false);
bool showCharIconFoldout = SessionState.GetBool(ShowCharIconsFoldoutKey, false);
bool showAvailableIcons = SessionState.GetBool(AvailableIconsFoldoutKey, true);
bool showSelectedIcons = SessionState.GetBool(SelectedIconsFoldoutKey, true);
#if UNITY_2019_3_OR_NEWER
showQuadIconFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(showQuadIconFoldout, "Quad Icons");
#else
showQuadIconFoldout = EditorGUILayout.Foldout(showQuadIconFoldout, "Quad Icons");
#endif
if (showQuadIconFoldout)
{
using (new EditorGUI.IndentLevelScope(1))
{
quadIconsProp.isExpanded = true;
EditorGUILayout.PropertyField(quadIconsProp, true);
}
}
#if UNITY_2019_3_OR_NEWER
EditorGUILayout.EndFoldoutHeaderGroup();
#endif
#if UNITY_2019_3_OR_NEWER
showSpriteIconFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(showSpriteIconFoldout, "Sprite Icons");
#else
showSpriteIconFoldout = EditorGUILayout.Foldout(showSpriteIconFoldout, "Sprite Icons");
#endif
if (showSpriteIconFoldout)
{
using (new EditorGUI.IndentLevelScope(1))
{
spriteIconsProp.isExpanded = true;
EditorGUILayout.PropertyField(spriteIconsProp, true);
}
}
#if UNITY_2019_3_OR_NEWER
EditorGUILayout.EndFoldoutHeaderGroup();
#endif
#if UNITY_2019_3_OR_NEWER
showCharIconFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(showCharIconFoldout, "Font Icons");
#else
showCharIconFoldout = EditorGUILayout.Foldout(showCharIconFoldout, "Font Icons");
#endif
#if UNITY_2019_3_OR_NEWER
EditorGUILayout.EndFoldoutHeaderGroup();
#endif
if (showCharIconFoldout)
{
EditorGUILayout.PropertyField(charIconFontProp);
if (charIconFontProp.objectReferenceValue == null)
{
EditorGUILayout.HelpBox(noIconFontMessage, MessageType.Warning);
if (!CheckIfHololensIconFontExists())
{
EditorGUILayout.HelpBox(downloadIconFontMessage, MessageType.Info);
if (GUILayout.Button("View Button Documentation"))
{
EditorApplication.ExecuteMenuItem(textMeshProMenuItem);
Application.OpenURL(hololensIconFontUrl);
}
}
}
else
{
TMP_FontAsset fontAsset = (TMP_FontAsset)charIconFontProp.objectReferenceValue;
#if UNITY_2019_3_OR_NEWER
showAvailableIcons = EditorGUILayout.BeginFoldoutHeaderGroup(showAvailableIcons, "Available Icons");
#else
showAvailableIcons = EditorGUILayout.Foldout(showAvailableIcons, "Available Icons");
#endif
if (showAvailableIcons)
{
if (fontAsset.characterTable.Count == 0)
{
EditorGUILayout.HelpBox("No icons are available in this font. The font may be configured incorrectly.", MessageType.Warning);
if (GUILayout.Button("Open Font Editor"))
{
Selection.activeObject = bis.CharIconFont;
}
}
else
{
EditorGUILayout.HelpBox("Click an icon to add it to your selected icons.", MessageType.Info);
if (GUILayout.Button("Open Font Editor"))
{
Selection.activeObject = bis.CharIconFont;
}
int removeIndex = -1;
int addIndex = -1;
int column = 0;
column = 0;
EditorGUILayout.BeginHorizontal();
for (int i = 0; i < fontAsset.characterTable.Count; i++)
{
if (column >= maxButtonsPerColumn)
{
column = 0;
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
}
if (GUILayout.Button(" ",
GUILayout.MinHeight(maxButtonSize),
GUILayout.MaxHeight(maxButtonSize),
GUILayout.MaxWidth(maxButtonSize)))
{
addIndex = i;
}
Rect textureRect = GUILayoutUtility.GetLastRect();
EditorDrawTMPGlyph(textureRect, fontAsset, fontAsset.characterTable[i]);
column++;
}
if (column > 0)
{
EditorGUILayout.EndHorizontal();
}
if (removeIndex >= 0)
{
List <CharIcon> charIconsSet = new List <CharIcon>(bis.charIcons);
charIconsSet.RemoveAt(removeIndex);
bis.charIcons = charIconsSet.ToArray();
EditorUtility.SetDirty(target);
}
if (addIndex >= 0)
{
uint unicode = fontAsset.characterTable[addIndex].unicode;
bool alreadyContainsIcon = false;
foreach (CharIcon c in bis.charIcons)
{
if (c.Character == unicode)
{
alreadyContainsIcon = true;
break;
}
}
if (!alreadyContainsIcon)
{
charIconsProp.InsertArrayElementAtIndex(charIconsProp.arraySize);
SerializedProperty newIconProp = charIconsProp.GetArrayElementAtIndex(charIconsProp.arraySize - 1);
SerializedProperty charProp = newIconProp.FindPropertyRelative("Character");
SerializedProperty nameProp = newIconProp.FindPropertyRelative("Name");
charProp.intValue = (int)unicode;
nameProp.stringValue = "Icon " + charIconsProp.arraySize.ToString();
serializedObject.ApplyModifiedProperties();
}
}
}
EditorGUILayout.Space();
}
#if UNITY_2019_3_OR_NEWER
EditorGUILayout.EndFoldoutHeaderGroup();
showSelectedIcons = EditorGUILayout.BeginFoldoutHeaderGroup(showSelectedIcons, "Selected Icons");
#else
showSelectedIcons = EditorGUILayout.Foldout(showSelectedIcons, "Selected Icons");
#endif
if (showSelectedIcons)
{
int removeIndex = -1;
if (charIconsProp.arraySize > 0)
{
EditorGUILayout.HelpBox("These icons will appear in the button config helper inspector. Click an icon to remove it from this list.", MessageType.Info);
using (new EditorGUILayout.VerticalScope())
{
for (int i = 0; i < charIconsProp.arraySize; i++)
{
SerializedProperty charIconNameprop = charIconsProp.GetArrayElementAtIndex(i).FindPropertyRelative("Name");
using (new EditorGUILayout.HorizontalScope())
{
if (GUILayout.Button(" ", GUILayout.MinHeight(maxButtonSize), GUILayout.MaxHeight(maxButtonSize)))
{
removeIndex = i;
}
Rect textureRect = GUILayoutUtility.GetLastRect();
EditorDrawTMPGlyph(textureRect, bis.charIcons[i].Character, fontAsset);
charIconNameprop.stringValue = EditorGUILayout.TextField(charIconNameprop.stringValue);
EditorGUILayout.Space();
}
EditorGUILayout.Space();
}
}
}
else
{
EditorGUILayout.HelpBox("No icons added yet. Click avaialable icons to add.", MessageType.Info);
}
if (removeIndex >= 0)
{
charIconsProp.DeleteArrayElementAtIndex(removeIndex);
}
}
#if UNITY_2019_3_OR_NEWER
EditorGUILayout.EndFoldoutHeaderGroup();
#endif
}
}
SessionState.SetBool(ShowQuadIconsFoldoutKey, showQuadIconFoldout);
SessionState.SetBool(ShowSpriteIconsFoldoutKey, showSpriteIconFoldout);
SessionState.SetBool(ShowCharIconsFoldoutKey, showCharIconFoldout);
SessionState.SetBool(AvailableIconsFoldoutKey, showAvailableIcons);
SessionState.SetBool(SelectedIconsFoldoutKey, showSelectedIcons);
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_SpawnSoundProp);
for (int i = 0; i < m_SpawnEventProp.arraySize; ++i)
{
var i1 = i;
m_FoldoutInfos[i] = EditorGUILayout.BeginFoldoutHeaderGroup(m_FoldoutInfos[i], $"Slot {i}", null, (rect) => { ShowHeaderContextMenu(rect, i1); });
if (m_FoldoutInfos[i])
{
var entriesArrayProp = m_SpawnEventProp.GetArrayElementAtIndex(i).FindPropertyRelative("Entries");
int localToDelete = -1;
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Item");
GUILayout.Label("Weight");
GUILayout.Space(16);
EditorGUILayout.EndHorizontal();
for (int j = 0; j < entriesArrayProp.arraySize; ++j)
{
var entryProp = entriesArrayProp.GetArrayElementAtIndex(j);
var itemProp = entryProp.FindPropertyRelative("Item");
var weightProp = entryProp.FindPropertyRelative("Weight");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PropertyField(itemProp, GUIContent.none);
EditorGUILayout.PropertyField(weightProp, GUIContent.none);
if (GUILayout.Button("-", GUILayout.Width(16)))
{
localToDelete = j;
}
EditorGUILayout.EndHorizontal();
}
if (localToDelete != -1)
{
entriesArrayProp.DeleteArrayElementAtIndex(localToDelete);
}
if (GUILayout.Button("Add New Entry", GUILayout.Width(100)))
{
entriesArrayProp.InsertArrayElementAtIndex(entriesArrayProp.arraySize);
}
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
if (toDelete != -1)
{
m_SpawnEventProp.DeleteArrayElementAtIndex(toDelete);
ArrayUtility.RemoveAt(ref m_FoldoutInfos, toDelete);
toDelete = -1;
}
if (GUILayout.Button("Add new Slot"))
{
m_SpawnEventProp.InsertArrayElementAtIndex(m_SpawnEventProp.arraySize);
serializedObject.ApplyModifiedProperties();
//insert will copy the last element, which can lead to having to empty a large spawn event to start new
//so we manually "empty" the new event
var newElem = m_SpawnEventProp.GetArrayElementAtIndex(m_SpawnEventProp.arraySize - 1);
var entries = newElem.FindPropertyRelative("Entries");
entries.ClearArray();
ArrayUtility.Add(ref m_FoldoutInfos, false);
}
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
//bool to show/hide the custom bit
custom = EditorGUILayout.ToggleLeft("Custom Inspector", custom);
if (custom)
{
//The players entry
EditorGUILayout.Space();
EditorGUILayout.LabelField("Player entry:");
EditorGUILayout.BeginHorizontal();
scr.playerEntry.Name = EditorGUILayout.TextField(scr.playerEntry.Name);
scr.playerEntry.Score = EditorGUILayout.FloatField(scr.playerEntry.Score);
EditorGUILayout.EndHorizontal();
//Button that sends the current entry to the leaderboard
if (GUILayout.Button("Write Entry"))
{
scr.WriteToLeaderboard(scr.playerEntry);
}
//Showing the highscore
if (scr.playerHigh != null)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Highscore:", GUILayout.Width(125));
EditorGUILayout.LabelField(scr.playerHigh.Name, GUILayout.Width(125));
EditorGUILayout.LabelField(scr.playerHigh.Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
setName = EditorGUILayout.TextField(setName, GUILayout.Width(200));
if (GUILayout.Button("Create Leaderboard"))
{
scr.AddLeaderboard(setName);
}
GUILayout.EndHorizontal();
for (int i = 0; i < scr.Leaderboards.Count; i++)
{
LeaderboardGroup lbg = scr.Leaderboards[i];
GUILayout.BeginHorizontal();
lbg.Show = EditorGUILayout.BeginFoldoutHeaderGroup(lbg.Show, lbg.Name);
if (GUILayout.Button("Remove Leaderboard", GUILayout.Width(175)))
{
scr.RemoveLeaderboard(lbg);
}
GUILayout.EndHorizontal();
if (lbg.Show)
{
EditorGUI.indentLevel = 1;
lbg.Name = EditorGUILayout.TextField("Name:", lbg.Name);
EditorGUILayout.Space();
//showing the closest in alltime
if (lbg.closestOverall != null)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Closest Overall:", GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestOverall.Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestOverall.Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
}
//showing the closest in alltime
if (lbg.closestAllTime != null)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Closest Alltime:", GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestAllTime.Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestAllTime.Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
}
//showing the closest in weekly
if (lbg.closestWeekly != null)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Closest Weekly:", GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestWeekly.Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestWeekly.Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
}
//showing the closest in daily
if (lbg.closestDaily != null)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Closest Daily:", GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestDaily.Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.closestDaily.Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.Space();
//Separating based on if the game is playing, to hide the settings you're not allowed to touch
if (!Application.isPlaying)
{
//Toggeling the leaderboards and showing their specific settings
lbg.EnableAllTime = EditorGUILayout.Toggle("Enable AllTime Leaderboard", lbg.EnableAllTime);
if (lbg.EnableAllTime)
{
EditorGUI.indentLevel = 1;
lbg.AllTime.Limit = EditorGUILayout.IntField("Alltime limit", lbg.AllTime.Limit);
EditorGUI.indentLevel = 0;
}
lbg.EnableWeekly = EditorGUILayout.Toggle("Enable Weekly Leaderboard", lbg.EnableWeekly);
if (lbg.EnableWeekly)
{
EditorGUI.indentLevel = 1;
lbg.Weekly.Limit = EditorGUILayout.IntField("Weekly limit", lbg.Weekly.Limit);
EditorGUI.indentLevel = 0;
}
lbg.EnableDaily = EditorGUILayout.Toggle("Enable Daily Leaderboard", lbg.EnableDaily);
if (lbg.EnableDaily)
{
EditorGUI.indentLevel = 1;
lbg.Daily.Limit = EditorGUILayout.IntField("Daily limit", lbg.Daily.Limit);
EditorGUI.indentLevel = 0;
}
}
else
{
//checking if leaderboard is enabled
if (lbg.EnableAllTime)
{
//Basic foldout to allow you to hide it
lbg.ShowAllTime = EditorGUILayout.Foldout(lbg.ShowAllTime, "AllTime Leaderboard");
if (lbg.ShowAllTime)
{
//indent the leaderboard, cause fancy
EditorGUI.indentLevel = 1;
//The signifier part,
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("nr.", GUILayout.Width(30));
EditorGUILayout.LabelField("Name:", GUILayout.Width(150));
EditorGUILayout.LabelField("Score:", GUILayout.Width(150));
EditorGUILayout.EndHorizontal();
//Scrollarea setup
lbg.allScrollPos = EditorGUILayout.BeginScrollView(lbg.allScrollPos, false, false, GUILayout.Height(Mathf.Clamp(21 * lbg.AllTime.Limit, 0, 300)), GUILayout.Width(330));
//going through all leaderboard entries and displaying them
for (int k = 0; k < lbg.AllTime.board.Count; k++)
{
//making the current players highscore green
if (scr.playerEntry.ID == lbg.AllTime.board[k].ID)
{
GUI.contentColor = Color.green;
}
//horizontaly displaying the entry
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField((k + 1).ToString() + ".", GUILayout.Width(50));
EditorGUILayout.LabelField(lbg.AllTime.board[k].Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.AllTime.board[k].Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
//stop being green
GUI.contentColor = Color.white;
}
//scrollarea end
EditorGUILayout.EndScrollView();
//stop indent
EditorGUI.indentLevel = 0;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
//same as above, not commenting the samey stuff
if (lbg.EnableWeekly)
{
lbg.ShowWeekly = EditorGUILayout.Foldout(lbg.ShowWeekly, "Weekly Leaderboard");
if (lbg.ShowWeekly)
{
EditorGUI.indentLevel = 1;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("nr.", GUILayout.Width(50));
EditorGUILayout.LabelField("Name:", GUILayout.Width(125));
EditorGUILayout.LabelField("Score:", GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
lbg.WeekScrollPos = EditorGUILayout.BeginScrollView(lbg.WeekScrollPos, false, false, GUILayout.Height(Mathf.Clamp(21 * lbg.Weekly.Limit, 0, 300)), GUILayout.Width(330));
for (int k = 0; k < lbg.Weekly.board.Count; k++)
{
if (scr.playerEntry.ID == lbg.Weekly.board[k].ID)
{
GUI.contentColor = Color.green;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField((k + 1).ToString() + ".", GUILayout.Width(50));
EditorGUILayout.LabelField(lbg.Weekly.board[k].Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.Weekly.board[k].Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
GUI.contentColor = Color.white;
}
EditorGUILayout.EndScrollView();
EditorGUI.indentLevel = 0;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
//same as above, not commenting the samey stuff
if (lbg.EnableDaily)
{
lbg.ShowDaily = EditorGUILayout.Foldout(lbg.ShowDaily, "Daily Leaderboard");
if (lbg.ShowDaily)
{
EditorGUI.indentLevel = 1;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("nr.", GUILayout.Width(50));
EditorGUILayout.LabelField("Name:", GUILayout.Width(125));
EditorGUILayout.LabelField("Score:", GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
lbg.dayScrollPos = EditorGUILayout.BeginScrollView(lbg.dayScrollPos, false, false, GUILayout.Height(Mathf.Clamp(21 * lbg.Daily.Limit, 0, 300)), GUILayout.Width(330));
for (int k = 0; k < lbg.Daily.board.Count; k++)
{
if (scr.playerEntry.ID == lbg.Daily.board[k].ID)
{
GUI.contentColor = Color.green;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField((k + 1).ToString() + ".", GUILayout.Width(50));
EditorGUILayout.LabelField(lbg.Daily.board[k].Name, GUILayout.Width(125));
EditorGUILayout.LabelField(lbg.Daily.board[k].Score.ToString(), GUILayout.Width(125));
EditorGUILayout.EndHorizontal();
GUI.contentColor = Color.white;
}
EditorGUILayout.EndScrollView();
EditorGUI.indentLevel = 0;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
}
EditorGUI.indentLevel = 0;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
if (!Application.isPlaying)
{
EditorGUILayout.Space();
//The settings foldout, serves to have them separated and hidden when they're not in use
settings = EditorGUILayout.BeginFoldoutHeaderGroup(settings, "Settings:");
if (settings)
{
EditorGUI.indentLevel = 1;
EditorGUILayout.HelpBox("Only change these if the leaderboards are empty", MessageType.Info);
scr.ReverseScore = EditorGUILayout.Toggle("Reverse boards", scr.ReverseScore);
scr.IncludeProductName = EditorGUILayout.Toggle("Include Name", scr.IncludeProductName);
scr.IncludeVersion = EditorGUILayout.Toggle("Include version", scr.IncludeVersion);
scr.databaseUrl = EditorGUILayout.TextField("Database Url", scr.databaseUrl);
EditorGUI.indentLevel = 0;
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
}
else
{
//Show the base if it's not in custom mode
EditorGUILayout.Space();
base.OnInspectorGUI();
}
//Mark any changes for saving
if (GUI.changed)
{
EditorUtility.SetDirty(scr);
}
}
public override void OnInspectorGUI()
{
base.OnPreInspectorGUI();
if (_foldoutColorsAndFormatting = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutColorsAndFormatting, "Colors & Formatting"))
{
DropDownField("Type", ref _ramp.data.RampType, _rampTypeStrings, _rampTypeValues);
TextureField("Image", ref _ramp.data.Image);
MaterialField("Material", ref _ramp.data.Material);
DropDownField("Image Mode", ref _ramp.data.ImageAlignment, _rampImageAlignmentStrings, _rampImageAlignmentValues);
ItemDataField("Apply Image To Wall", ref _ramp.data.ImageWalls);
ItemDataField("Visible", ref _ramp.data.IsVisible);
ItemDataField("Depth Bias", ref _ramp.data.DepthBias);
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (_foldoutPosition = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutPosition, "Position"))
{
ItemDataField("Top Height", ref _ramp.data.HeightTop);
ItemDataField("Bottom Height", ref _ramp.data.HeightBottom);
EditorGUILayout.Space(10);
ItemDataField("Top Width", ref _ramp.data.WidthTop);
ItemDataField("Bottom Width", ref _ramp.data.WidthBottom);
EditorGUILayout.Space(10);
EditorGUILayout.LabelField("Visible Wall");
EditorGUI.indentLevel++;
ItemDataField("Left Wall", ref _ramp.data.LeftWallHeightVisible);
ItemDataField("Right Wall", ref _ramp.data.RightWallHeightVisible);
EditorGUI.indentLevel--;
EditorGUILayout.LabelField("Wire Ramp");
EditorGUI.indentLevel++;
ItemDataField("Diameter", ref _ramp.data.WireDiameter);
ItemDataField("Distance X", ref _ramp.data.WireDistanceX);
ItemDataField("Distance Y", ref _ramp.data.WireDistanceY);
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (_foldoutPhysics = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutPhysics, "Physics"))
{
ItemDataField("Has Hit Event", ref _ramp.data.HitEvent, dirtyMesh: false);
ItemDataField("Hit Threshold", ref _ramp.data.Threshold, dirtyMesh: false);
EditorGUILayout.LabelField("Physical Wall");
EditorGUI.indentLevel++;
ItemDataField("Left Wall", ref _ramp.data.LeftWallHeight);
ItemDataField("Right Wall", ref _ramp.data.RightWallHeight);
EditorGUI.indentLevel--;
EditorGUI.BeginDisabledGroup(_ramp.data.OverwritePhysics);
MaterialField("Physics Material", ref _ramp.data.PhysicsMaterial, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
ItemDataField("Overwrite Material Settings", ref _ramp.data.OverwritePhysics, dirtyMesh: false);
EditorGUI.BeginDisabledGroup(!_ramp.data.OverwritePhysics);
ItemDataField("Elasticity", ref _ramp.data.Elasticity, dirtyMesh: false);
ItemDataField("Friction", ref _ramp.data.Friction, dirtyMesh: false);
ItemDataField("Scatter Angle", ref _ramp.data.Scatter, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
ItemDataField("Collidable", ref _ramp.data.IsCollidable, dirtyMesh: false);
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (_foldoutMisc = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutMisc, "Misc"))
{
ItemDataField("Timer Enabled", ref _ramp.data.IsTimerEnabled, dirtyMesh: false);
ItemDataField("Timer Interval", ref _ramp.data.TimerInterval, dirtyMesh: false);
}
EditorGUILayout.EndFoldoutHeaderGroup();
base.OnInspectorGUI();
}
public override void OnInspectorGUI()
{
OnPreInspectorGUI();
if (_foldoutColorsAndFormatting = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutColorsAndFormatting, "Colors & Formatting"))
{
GUILayout.BeginHorizontal();
MeshImporterGui();
if (GUILayout.Button("Export Mesh"))
{
ExportMesh();
}
GUILayout.EndHorizontal();
TextureField("Image", ref _prim.data.Image);
TextureField("Normal Map", ref _prim.data.NormalMap);
EditorGUI.indentLevel++;
ItemDataField("Object Space", ref _prim.data.ObjectSpaceNormalMap);
EditorGUI.indentLevel--;
MaterialField("Material", ref _prim.data.Material);
ItemDataField("Visible", ref _prim.data.IsVisible);
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (_foldoutPosition = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutPosition, "Position & Translation"))
{
EditorGUILayout.LabelField("Base Position");
EditorGUI.indentLevel++;
ItemDataField("", ref _prim.data.Position);
EditorGUI.indentLevel--;
EditorGUILayout.LabelField("Base Size");
EditorGUI.indentLevel++;
ItemDataField("", ref _prim.data.Size);
EditorGUI.indentLevel--;
EditorGUILayout.LabelField("Rotation and Transposition");
EditorGUI.indentLevel++;
ItemDataField("0: RotX", ref _prim.data.RotAndTra[0]);
ItemDataField("1: RotY", ref _prim.data.RotAndTra[1]);
ItemDataField("2: RotZ", ref _prim.data.RotAndTra[2]);
ItemDataField("3: TransX", ref _prim.data.RotAndTra[3]);
ItemDataField("4: TransY", ref _prim.data.RotAndTra[4]);
ItemDataField("5: TransZ", ref _prim.data.RotAndTra[5]);
ItemDataField("6: ObjRotX", ref _prim.data.RotAndTra[6]);
ItemDataField("7: ObjRotY", ref _prim.data.RotAndTra[7]);
ItemDataField("8: ObjRotZ", ref _prim.data.RotAndTra[8]);
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (_foldoutPhysics = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutPhysics, "Physics"))
{
EditorGUI.BeginDisabledGroup(_prim.data.IsToy || !_prim.data.IsCollidable);
ItemDataField("Has Hit Event", ref _prim.data.HitEvent, dirtyMesh: false);
EditorGUI.BeginDisabledGroup(!_prim.data.HitEvent);
ItemDataField("Has Hit Event", ref _prim.data.Threshold, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(_prim.data.OverwritePhysics);
MaterialField("Physics Material", ref _prim.data.PhysicsMaterial, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
ItemDataField("Overwrite Material Settings", ref _prim.data.OverwritePhysics, dirtyMesh: false);
EditorGUI.BeginDisabledGroup(!_prim.data.OverwritePhysics);
ItemDataField("Elasticity", ref _prim.data.Elasticity, dirtyMesh: false);
ItemDataField("Elasticity Falloff", ref _prim.data.ElasticityFalloff, dirtyMesh: false);
ItemDataField("Friction", ref _prim.data.Friction, dirtyMesh: false);
ItemDataField("Scatter Angle", ref _prim.data.Scatter, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(_prim.data.IsToy);
ItemDataField("Collidable", ref _prim.data.IsCollidable, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
ItemDataField("Toy", ref _prim.data.IsToy, dirtyMesh: false);
EditorGUI.BeginDisabledGroup(_prim.data.IsToy);
ItemDataSlider("Reduce Polygons By", ref _prim.data.CollisionReductionFactor, 0f, 1f, dirtyMesh: false);
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndFoldoutHeaderGroup();
base.OnInspectorGUI();
}
public override void OnInspectorGUI()
{
if (!m_Target)
{
return;
}
using (new EditorGUILayout.HorizontalScope())
{
if (GUILayout.Button("Populate"))
{
m_Target.Populate();
}
if (GUILayout.Button("Apply"))
{
m_Target.Apply();
}
if (GUILayout.Button("Reset"))
{
m_Target.Reset();
RefreshEditors();
Repaint();
}
}
serializedObject.Update();
if (m_Target.renderers.Length == 0)
{
EditorGUILayout.HelpBox($"{typeof(MaterialOverrideGroup)} contains no renderers.", MessageType.Info);
return;
}
// Find null renderers
var oldRenderers = new List <Renderer>();
foreach (var renderer in m_Target.renderers)
{
if (renderer == null)
{
continue;
}
oldRenderers.Add(renderer);
}
// Remove null renderers
if (oldRenderers.Count != m_Renderers.arraySize)
{
m_Renderers.ClearArray();
foreach (var renderer in oldRenderers)
{
m_Renderers.arraySize += 1;
m_Renderers.GetArrayElementAtIndex(m_Renderers.arraySize - 1).objectReferenceValue = (Object)renderer;
}
}
EditorGUI.BeginChangeCheck();
CoreEditorUtils.DrawSplitter();
m_ShaderOverridesFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_ShaderOverridesFoldout.value, "Shader Overrides");
if (m_ShaderOverridesFoldout.value)
{
var targetShaders = m_Target.shaders;
for (int i = 0, count = targetShaders.Length; i < count; i++)
{
if (!m_Target.TryGetOverride(targetShaders[i], out var propertyOverrideList))
{
continue;
}
if (!m_ShaderOverrideEditors.TryGetValue(propertyOverrideList, out var editor))
{
continue;
}
// Draw material header
CoreEditorUtils.DrawSplitter();
bool displayContent = CoreEditorUtils.DrawHeaderToggle(
targetShaders[i].name,
editor.baseProperty,
editor.active,
null,
() => editor.showHidden,
() => editor.showHidden = !editor.showHidden
);
if (displayContent)
{
using (new EditorGUI.DisabledScope(!editor.active.boolValue))
{
editor.OnInspectorGUI();
}
}
}
if (m_Target.shaders.Length == 0)
{
EditorGUILayout.HelpBox($"{typeof(MaterialOverrideGroup)} contains no shaders.", MessageType.Info);
}
}
EditorGUILayout.EndFoldoutHeaderGroup();
CoreEditorUtils.DrawSplitter();
m_MaterialOverridesFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_MaterialOverridesFoldout.value, "Material Overrides");
if (m_MaterialOverridesFoldout.value)
{
var targetMaterials = m_Target.materials;
// Draw materials
for (int i = 0, count = targetMaterials.Length; i < count; i++)
{
if (!m_Target.TryGetOverride(targetMaterials[i], out var propertyOverrideList))
{
continue;
}
if (!m_ShaderOverrideEditors.TryGetValue(propertyOverrideList, out var editor))
{
continue;
}
// Draw material header
CoreEditorUtils.DrawSplitter();
bool displayContent = CoreEditorUtils.DrawHeaderToggle(
targetMaterials[i].name,
editor.baseProperty,
editor.active,
null,
() => editor.showHidden,
() => editor.showHidden = !editor.showHidden
);
if (displayContent)
{
using (new EditorGUI.DisabledScope(!editor.active.boolValue))
{
editor.OnInspectorGUI();
}
}
}
if (m_Target.materials.Length == 0)
{
EditorGUILayout.HelpBox($"{typeof(MaterialOverrideGroup)} contains no materials.", MessageType.Info);
}
}
EditorGUILayout.EndFoldoutHeaderGroup();
serializedObject.ApplyModifiedProperties();
if (EditorGUI.EndChangeCheck())
{
m_Target.Apply();
}
}
void OnGUI()
{
GUILayout.BeginHorizontal();
GUILayout.Label("Quest Sabers", EditorStyles.boldLabel);
if (GUILayout.Button("Go to saber scene"))
{
EditorSceneManager.OpenScene("Assets/scenes/questsabers.unity");
OnFocus();
}
if (GUILayout.Button("Add New Saber Template"))
{
AddSaberTemplate();
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
if (GUILayout.Button("Export all Active sabers"))
{
ExportAll();
}
if (GUILayout.Button("Export and Upload all Active sabers"))
{
ExportAllAndUpload();
}
GUILayout.Space(10);
foreach (var saber in questsabers)
{
if (saber == null)
{
continue;
}
GUILayout.Label("GameObject : " + saber.gameObject.name, EditorStyles.boldLabel);
saber.descriptorFolded = EditorGUILayout.BeginFoldoutHeaderGroup(saber.descriptorFolded, "Saber Descriptor");
if (saber.descriptorFolded)
{
GUILayout.Space(5);
DescriptorDisplay(saber);
}
EditorGUILayout.EndFoldoutHeaderGroup();
GUILayout.Space(5);
saber.configFolded = EditorGUILayout.BeginFoldoutHeaderGroup(saber.configFolded, "Saber config");
if (saber.configFolded)
{
SaberConfigDisplay(saber);
}
EditorGUILayout.EndFoldoutHeaderGroup();
EditorGUILayout.Space(10);
bool disableExport = shouldDisableExport(saber);
if (disableExport && exporterConfig.forceAllowExport)
{
GUILayout.Label("WARNING! force allow export is set to true so this saber file is unlikely to work correctly in game!", EditorStyles.boldLabel);
}
EditorGUI.BeginDisabledGroup(disableExport && !exporterConfig.forceAllowExport);
if (GUILayout.Button("Export " + saber.descriptor.objectName + "." + extension))
{
ExportSaberFile(saber);
}
if (GUILayout.Button("Export and Upload " + saber.descriptor.objectName + "." + extension + " To Quest"))
{
ExportAndUpload(saber);
}
EditorGUI.EndDisabledGroup();
if (QosmeticUtils.GetObjectBounds(saber.gameObject).extents.z * 2.0 > 2.0)
{
GUILayout.Label("The saber might be too long", EditorStyles.boldLabel);
}
if (QosmeticUtils.GetObjectBounds(saber.gameObject).extents.z * 2.0 < 0.5)
{
GUILayout.Label("The saber might be too short", EditorStyles.boldLabel);
}
if (QosmeticUtils.GetObjectBounds(saber.gameObject).extents.x * 2.0 > 1.0)
{
GUILayout.Label("The saber might be too large", EditorStyles.boldLabel);
}
if (debug)
{
if (GUILayout.Button("Log config json"))
{
SetTrailConfigs(saber);
Debug.Log(JsonUtility.ToJson(saber.config, true));
}
}
}
}
public override void OnInspectorGUI()
{
serializedObject.Update();
gameVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(gameVariablesFoldout, "Game variables", header1Style);
EditorGUILayout.EndFoldoutHeaderGroup();
EditorGUILayout.Space(5);
if (gameVariablesFoldout)
{
boardVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(boardVariablesFoldout, "Board variables", header2Style);
if (boardVariablesFoldout)
{
EditorGUILayout.PropertyField(boardWidth);
EditorGUILayout.PropertyField(boardHeight);
EditorGUILayout.PropertyField(spawnPos);
}
EditorGUILayout.EndFoldoutHeaderGroup();
EditorGUILayout.Space(10);
movementVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(movementVariablesFoldout, "Movement variables", header2Style);
if (movementVariablesFoldout)
{
EditorGUILayout.PropertyField(gravityDropLimit);
EditorGUILayout.PropertyField(softDropLimit);
EditorGUILayout.PropertyField(horMovLimit);
EditorGUILayout.PropertyField(lockedLimitTime);
}
EditorGUILayout.EndFoldoutHeaderGroup();
EditorGUILayout.Space(10);
scoreVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(scoreVariablesFoldout, "Score and other variables", header2Style);
if (scoreVariablesFoldout)
{
EditorGUILayout.PropertyField(linesToLevelUp);
EditorGUILayout.PropertyField(possibleScores);
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
EditorGUILayout.Space(10);
/*botVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(botVariablesFoldout, "Bot variables", header1Style);
*
* EditorGUILayout.EndFoldoutHeaderGroup();
*
* EditorGUILayout.Space(5);
*
* if (botVariablesFoldout)
* {
* EditorGUILayout.PropertyField(botVersion);
* EditorGUILayout.PropertyField(generation);
* EditorGUILayout.PropertyField(initialActionTime);
* EditorGUILayout.PropertyField(nextActionsTime);
*
* EditorGUILayout.Space(10);
*
* botWeightsFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(botWeightsFoldout, "Bot weights", header2Style);
*
* if(botWeightsFoldout)
* {
* EditorGUILayout.PropertyField(holesWeight);
* EditorGUILayout.PropertyField(bumpinessWeight);
* EditorGUILayout.PropertyField(linesWeight);
* EditorGUILayout.PropertyField(linesHolesWeight);
* EditorGUILayout.PropertyField(humanizedWeight);
* }
*
* EditorGUILayout.EndFoldoutHeaderGroup();
*
* EditorGUILayout.Space(10);
*
* geneticAlgorithmVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(geneticAlgorithmVariablesFoldout, "Genetic algorithm variables", header2Style);
*
* if(geneticAlgorithmVariablesFoldout)
* {
* EditorGUILayout.PropertyField(populationSize);
* EditorGUILayout.PropertyField(mutationRate);
* EditorGUILayout.PropertyField(pieceLimitTraining);
* }
*
* EditorGUILayout.EndFoldoutHeaderGroup();
*
* EditorGUILayout.Space(10);
*
* testingVariablesFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(testingVariablesFoldout, "Testing variables", header2Style);
*
* if(testingVariablesFoldout)
* {
* EditorGUILayout.PropertyField(initialCalculationTime);
* EditorGUILayout.PropertyField(decreasingCalculationTimeFactor);
* }
*
* EditorGUILayout.EndFoldoutHeaderGroup();
* }
*
* EditorGUILayout.Space(10);*/
EditorGUILayout.PropertyField(debugMode);
serializedObject.ApplyModifiedProperties();
}
public void OnTransformField(Transform owner)
{
toggle = EditorGUILayout.BeginFoldoutHeaderGroup(toggle, "出生挂点");
if (toggle)
{
if (owner)
{
EditorGUILayout.BeginHorizontal();
//bool searchChange = false;
var s = EditorGUILayout.TextField(search);
if (s != search)
{
//searchChange = true;
search = s;
}
var transforms = owner.GetComponentsInChildren <Transform>().Select(r => r.fullName()).Select(r => r.Replace("/", "$")).ToList();
if (!string.IsNullOrEmpty(search))
{
transforms = transforms.FindAll(r => Regex.IsMatch(r, search, RegexOptions.IgnoreCase));
}
if (transforms.Count > 0)
{
//if (searchChange)
//{
if (Node.transformPath == null)
{
Node.transformPath = string.Empty;
}
var findIndex = transforms.FindIndex(r => r.Contains(Node.transformPath.Replace("/", "$")));
Node.transformIndex = findIndex == -1 ? 0 : findIndex;
//}
var index = EditorGUILayout.Popup(Node.transformIndex, transforms.ToArray());
var root = transforms[Node.transformIndex];
if (index != Node.transformIndex)
{
root = transforms[index];
}
if (root.Contains("$"))
{
root = root.Substring(root.IndexOf("$") + 1);
Node.transformPath = root.Replace("$", "/");
Node.transform = owner.transform.Find(Node.transformPath);
}
else
{
Node.transformPath = "";
Node.transform = owner.transform;
}
}
else
{
EditorGUILayout.LabelField("查找失败");
//Node.transformPath = "";
//Node.transform = owner.transform;
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.ObjectField(Node.transform, typeof(Transform), false);
Node.isWorld = EditorGUILayout.Toggle("世界", Node.isWorld);
Node.localPosition = EditorGUILayout.Vector3Field("offset", Node.localPosition);
Node.localEulerAngles = EditorGUILayout.Vector3Field("eulur", Node.localEulerAngles);
Node.localScale = EditorGUILayout.Vector3Field("scale", Node.localScale);
}
EditorGUILayout.EndFoldoutHeaderGroup();
}
