private void DrawInputNodesSection(HEU_HoudiniAsset asset, SerializedObject assetObject) { List<HEU_InputNode> inputNodes = asset.GetNonParameterInputNodes(); if (inputNodes.Count > 0) { HEU_EditorUI.BeginSection(); SerializedProperty showInputNodesProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_showInputNodesSection"); if (showInputNodesProperty != null) { showInputNodesProperty.boolValue = HEU_EditorUI.DrawFoldOut(showInputNodesProperty.boolValue, "INPUT NODES"); if (showInputNodesProperty.boolValue) { foreach (HEU_InputNode inputNode in inputNodes) { HEU_InputNodeUI.EditorDrawInputNode(inputNode); if (inputNodes.Count > 1) { HEU_EditorUI.DrawSeparator(); } } } HEU_EditorUI.DrawSeparator(); } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); } }
/// <summary> /// Draw asset options for given asset. /// </summary> /// <param name="asset">The HDA asset</param> /// <param name="assetObject">Serialized HDA asset object</param> private void DrawAssetOptions(HEU_HoudiniAsset asset, SerializedObject assetObject) { HEU_EditorUI.BeginSection(); { SerializedProperty showHDAOptionsProperty = assetObject.FindProperty("_showHDAOptions"); showHDAOptionsProperty.boolValue = HEU_EditorUI.DrawFoldOut(showHDAOptionsProperty.boolValue, "ASSET OPTIONS"); if (showHDAOptionsProperty.boolValue) { EditorGUI.indentLevel++; HEU_EditorUI.DrawPropertyField(assetObject, "_autoCookOnParameterChange", "Auto-Cook On Parameter Change"); HEU_EditorUI.DrawPropertyField(assetObject, "_pushTransformToHoudini", "Push Transform To Houdini"); HEU_EditorUI.DrawPropertyField(assetObject, "_transformChangeTriggersCooks", "Transform Change Triggers Cooks"); HEU_EditorUI.DrawPropertyField(assetObject, "_cookingTriggersDownCooks", "Cooking Triggers Downstream Cooks"); HEU_EditorUI.DrawPropertyField(assetObject, "_generateUVs", "Generate UVs"); HEU_EditorUI.DrawPropertyField(assetObject, "_generateTangents", "Generate Tangents"); HEU_EditorUI.DrawPropertyField(assetObject, "_ignoreNonDisplayNodes", "Ignore NonDisplay Nodes"); if (asset.NumAttributeStores() > 0) { HEU_EditorUI.DrawPropertyField(assetObject, "_editableNodesToolsEnabled", "Enable Editable Node Tools"); } if (asset.NumHandles() > 0) { HEU_EditorUI.DrawPropertyField(assetObject, "_handlesEnabled", "Enable Handles"); } EditorGUI.indentLevel--; } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
private bool DrawDetailsGeometry() { bool bChanged = false; EditorGUIUtility.labelWidth = 250; // TODO { bool oldValue = HEU_PluginSettings.Curves_ShowInSceneView; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Show Curves in Scene View"); if (newValue != oldValue) { HEU_PluginSettings.Curves_ShowInSceneView = newValue; HEU_HoudiniAsset.SetCurvesVisibilityInScene(newValue); bChanged = true; } } HEU_EditorUI.DrawSeparator(); { float oldValue = HEU_PluginSettings.NormalGenerationThresholdAngle; float newValue = EditorGUILayout.DelayedFloatField("Normal Generation Threshold Angle", oldValue); if (newValue != oldValue) { HEU_PluginSettings.NormalGenerationThresholdAngle = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); EditorGUIUtility.labelWidth = 0; return bChanged; }
private static bool DrawSection(HEU_SettingsWindow settingsWindow, string sectionLabel, DrawDetailsDelegate drawDetailsDelegate, ref bool foldoutState) { bool bChanged = false; HEU_EditorUI.BeginSection(); { foldoutState = HEU_EditorUI.DrawFoldOut(foldoutState, sectionLabel); if (foldoutState) { HEU_EditorUI.DrawSeparator(); EditorGUI.indentLevel++; using (var hs = new EditorGUILayout.HorizontalScope()) { using (var vs = new EditorGUILayout.VerticalScope()) { bChanged |= drawDetailsDelegate(); } } EditorGUI.indentLevel--; } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); return bChanged; }
private bool DrawToolSettings() { bool bChanged = false; HEU_EditorUI.DrawSeparator(); { float oldValue = HEU_PluginSettings.ImageGamma; float newValue = EditorGUILayout.DelayedFloatField("Texture Gamma", oldValue); if (newValue != oldValue) { HEU_PluginSettings.ImageGamma = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { Color oldValue = HEU_PluginSettings.LineColor; Color newValue = EditorGUILayout.ColorField("Line Color", oldValue); if (newValue != oldValue) { HEU_PluginSettings.LineColor = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); return bChanged; }
/// <summary> /// Draw Asset Events section. /// </summary> /// <param name="asset"></param> /// <param name="assetObject"></param> private void DrawEventsSection(HEU_HoudiniAsset asset, SerializedObject assetObject) { HEU_EditorUI.BeginSection(); { SerializedProperty showEventsProperty = assetObject.FindProperty("_showEventsSection"); showEventsProperty.boolValue = HEU_EditorUI.DrawFoldOut(showEventsProperty.boolValue, "EVENTS"); if (showEventsProperty.boolValue) { HEU_EditorUI.DrawSeparator(); SerializedProperty reloadEvent = assetObject.FindProperty("_reloadEvent"); EditorGUILayout.PropertyField(reloadEvent, new GUIContent("Rebuild Events")); HEU_EditorUI.DrawSeparator(); SerializedProperty recookEvent = assetObject.FindProperty("_cookedEvent"); EditorGUILayout.PropertyField(recookEvent, new GUIContent("Cooked Events")); HEU_EditorUI.DrawSeparator(); SerializedProperty bakedEvent = assetObject.FindProperty("_bakedEvent"); EditorGUILayout.PropertyField(bakedEvent, new GUIContent("Baked Events")); } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
private bool DrawDetailsEnvironment() { bool bChanged = false; { string oldPath = HEU_PluginSettings.HoudiniEngineEnvFilePath; string fileExt = "env"; using (new EditorGUILayout.HorizontalScope()) { string newPath = EditorGUILayout.DelayedTextField(new GUIContent("Houdini Env File", "Assets/ relative path to unity_houdini.env file containing environment paths"), oldPath); GUIStyle buttonStyle = HEU_EditorUI.GetNewButtonStyle_MarginPadding(0, 0); if (GUILayout.Button("...", buttonStyle, GUILayout.Width(30), GUILayout.Height(18))) { string openFilePath = UnityEditor.EditorUtility.OpenFilePanel("Select Houdini Env file", newPath, fileExt); if (!string.IsNullOrEmpty(openFilePath)) { newPath = openFilePath; } } if (!newPath.Equals(oldPath)) { HEU_PluginSettings.HoudiniEngineEnvFilePath = newPath; bChanged = true; } GUILayout.Space(5); if (GUILayout.Button(_refreshContent, buttonStyle, GUILayout.Width(40), GUILayout.Height(18))) { HEU_PluginStorage.Instance.LoadAssetEnvironmentPaths(); } } } HEU_EditorUI.DrawSeparator(); Dictionary<string, string> envMap = HEU_PluginStorage.Instance.GetEnvironmentPathMap(); if (envMap == null) { HEU_EditorUI.DrawHeadingLabel("No environment mapped paths found!"); } else { HEU_EditorUI.DrawHeadingLabel("Enviornment Mapped Paths:"); EditorGUILayout.LabelField("The following mappings will be applied to assets loaded from outside the Assets/ folder."); foreach (KeyValuePair<string, string> pair in envMap) { EditorGUILayout.LabelField(string.Format("{0} = {1}", pair.Key, pair.Value)); } HEU_EditorUI.DrawSeparator(); } return bChanged; }
private bool DrawDetailsCooking() { bool bChanged = false; { bool oldValue = HEU_PluginSettings.CookingEnabled; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Enable Cooking"); if (newValue != oldValue) { HEU_PluginSettings.CookingEnabled = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { bool oldValue = HEU_PluginSettings.CookingTriggersDownstreamCooks; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Cooking Triggers Downstream Cooks"); if (newValue != oldValue) { HEU_PluginSettings.CookingTriggersDownstreamCooks = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { bool oldValue = HEU_PluginSettings.PushUnityTransformToHoudini; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Push Unity Transform To Houdini"); if (newValue != oldValue) { HEU_PluginSettings.PushUnityTransformToHoudini = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { bool oldValue = HEU_PluginSettings.TransformChangeTriggersCooks; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Transform Change Triggers Cooks"); if (newValue != oldValue) { HEU_PluginSettings.TransformChangeTriggersCooks = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { bool oldValue = HEU_PluginSettings.CookTemplatedGeos; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Import Templated Geos"); if (newValue != oldValue) { HEU_PluginSettings.CookTemplatedGeos = newValue; bChanged = true; } } return bChanged; }
private void DrawNoHDAInfo() { HEU_EditorUI.DrawSeparator(); GUIStyle labelStyle = new GUIStyle(GUI.skin.label); labelStyle.fontStyle = FontStyle.Bold; labelStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.yellow : Color.red; EditorGUILayout.LabelField("Houdini Engine Asset - no HEU_HoudiniAsset found!", labelStyle); HEU_EditorUI.DrawSeparator(); }
/// <summary> /// Draw the Houdini Engine header image /// </summary> void DrawHeaderSection() { GUI.backgroundColor = new Color(0.2f, 0.2f, 0.2f); Texture2D headerImage = Resources.Load("heu_hengine") as Texture2D; HEU_EditorUI.BeginSection(); GUILayout.Label(headerImage, GUILayout.MinWidth(100)); HEU_EditorUI.EndSection(); GUI.backgroundColor = Color.white; HEU_EditorUI.DrawSeparator(); }
/// <summary> /// Draw the Houdini Engine header image /// </summary> public static void DrawHeaderSection() { GUI.backgroundColor = new Color(0.2f, 0.2f, 0.2f); string fileName = HEU_EditorUI.IsEditorDarkSkin() ? "heu_hengine_d" : "heu_hengine"; Texture2D headerImage = Resources.Load(fileName) as Texture2D; HEU_EditorUI.DrawSeparator(); //HEU_EditorUI.BeginSection(); GUILayout.Label(headerImage); //HEU_EditorUI.EndSection(); GUI.backgroundColor = Color.white; }
private void DrawHDAUIMessage(string msg) { HEU_EditorUI.DrawSeparator(); GUIStyle labelStyle = new GUIStyle(GUI.skin.label); labelStyle.fontStyle = FontStyle.Bold; labelStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.yellow : Color.red; labelStyle.alignment = TextAnchor.MiddleCenter; labelStyle.wordWrap = true; EditorGUILayout.LabelField(msg, labelStyle); HEU_EditorUI.DrawSeparator(); }
/// <summary> /// Draw asset options for given asset. /// </summary> /// <param name="asset">The HDA asset</param> /// <param name="assetObject">Serialized HDA asset object</param> private void DrawAssetOptions(HEU_HoudiniAsset asset, SerializedObject assetObject) { GUIStyle buttonStyle = new GUIStyle(GUI.skin.button); buttonStyle.fontSize = 11; buttonStyle.alignment = TextAnchor.MiddleCenter; buttonStyle.fixedHeight = 24; buttonStyle.margin.left = 34; HEU_EditorUI.BeginSection(); { SerializedProperty showHDAOptionsProperty = assetObject.FindProperty("_showHDAOptions"); showHDAOptionsProperty.boolValue = HEU_EditorUI.DrawFoldOut(showHDAOptionsProperty.boolValue, "ASSET OPTIONS"); if (showHDAOptionsProperty.boolValue) { EditorGUI.indentLevel++; HEU_EditorUI.DrawPropertyField(assetObject, "_autoCookOnParameterChange", "Auto-Cook On Parameter Change"); HEU_EditorUI.DrawPropertyField(assetObject, "_pushTransformToHoudini", "Push Transform To Houdini"); HEU_EditorUI.DrawPropertyField(assetObject, "_transformChangeTriggersCooks", "Transform Change Triggers Cooks"); HEU_EditorUI.DrawPropertyField(assetObject, "_cookingTriggersDownCooks", "Cooking Triggers Downstream Cooks"); HEU_EditorUI.DrawPropertyField(assetObject, "_generateUVs", "Generate UVs"); HEU_EditorUI.DrawPropertyField(assetObject, "_generateTangents", "Generate Tangents"); HEU_EditorUI.DrawPropertyField(assetObject, "_generateNormals", "Generate Normals"); HEU_EditorUI.DrawPropertyField(assetObject, "_generateMeshUsingPoints", "Generate Mesh Using Points"); HEU_EditorUI.DrawPropertyField(assetObject, "_useLODGroups", "Use LOD Groups"); HEU_EditorUI.DrawPropertyField(assetObject, "_ignoreNonDisplayNodes", "Ignore NonDisplay Nodes"); if (asset.NumAttributeStores() > 0) { HEU_EditorUI.DrawPropertyField(assetObject, "_editableNodesToolsEnabled", "Enable Editable Node Tools"); } if (asset.NumHandles() > 0) { HEU_EditorUI.DrawPropertyField(assetObject, "_handlesEnabled", "Enable Handles"); } EditorGUILayout.Space(); if(GUILayout.Button(_resetMaterialOverridesButton, buttonStyle, GUILayout.MaxWidth(180))) { asset.ResetMaterialOverrides(); } EditorGUI.indentLevel--; } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
private void DrawCurvesSection(HEU_HoudiniAsset asset, SerializedObject assetObject) { if (asset.GetEditableCurveCount() <= 0) { return; } HEU_EditorUI.BeginSection(); { SerializedProperty showCurvesProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_showCurvesSection"); if (showCurvesProperty != null) { showCurvesProperty.boolValue = HEU_EditorUI.DrawFoldOut(showCurvesProperty.boolValue, "CURVES"); if (showCurvesProperty.boolValue) { SerializedProperty curveEditorProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_curveEditorEnabled"); if (curveEditorProperty != null) { EditorGUILayout.PropertyField(curveEditorProperty); } SerializedProperty curveCollisionProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_curveDrawCollision"); if (curveCollisionProperty != null) { EditorGUILayout.PropertyField(curveCollisionProperty, new GUIContent("Draw Collision Type")); if (curveCollisionProperty.enumValueIndex == (int)HEU_Curve.CurveDrawCollision.COLLIDERS) { HEU_EditorUtility.EditorDrawSerializedProperty(assetObject, "_curveDrawColliders", label: "Colliders"); } else if (curveCollisionProperty.enumValueIndex == (int)HEU_Curve.CurveDrawCollision.LAYERMASK) { HEU_EditorUtility.EditorDrawSerializedProperty(assetObject, "_curveDrawLayerMask", label: "Layer Mask"); } } List<HEU_Curve> curves = asset.GetCurves(); for (int i = 0; i < curves.Count; ++i) { if (curves[i].Parameters != null) { DrawParameters(curves[i].Parameters, ref _curveParameterEditor); } } } } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
/// <summary> /// Draw Houdini Engine license info. /// </summary> private void DrawLicenseInfo() { HAPI_License license = HEU_SessionManager.GetCurrentLicense(false); if (license == HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE) { HEU_EditorUI.DrawSeparator(); GUIStyle labelStyle = new GUIStyle(GUI.skin.label); labelStyle.fontStyle = FontStyle.Bold; labelStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.yellow : Color.red; EditorGUILayout.LabelField("Houdini Engine Indie - For Limited Commercial Use Only", labelStyle); HEU_EditorUI.DrawSeparator(); } }
private bool DrawToolSettings() { bool bChanged = false; HEU_EditorUI.DrawSeparator(); { float oldValue = HEU_PluginSettings.ImageGamma; float newValue = EditorGUILayout.DelayedFloatField("Texture Gamma", oldValue); if (newValue != oldValue) { HEU_PluginSettings.ImageGamma = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { Color oldValue = HEU_PluginSettings.LineColor; Color newValue; if (HEU_PluginSettings.UseHDRColor) { newValue = EditorGUILayout.ColorField(new GUIContent("Line Color", "Color of the line"), oldValue, true, true, true); } else { newValue = EditorGUILayout.ColorField(new GUIContent("Line Color", "Color of the line"), oldValue); } if (newValue != oldValue) { HEU_PluginSettings.LineColor = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { bool oldValue = HEU_PluginSettings.UseHybridCurveEditing; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Use Hybrid Curve Editing", "Toggles the usage of 'Hybrid Curve Editing', which overrides the shift function when working with curves."); if (oldValue != newValue) { HEU_PluginSettings.UseHybridCurveEditing = newValue; bChanged = true; } } return bChanged; }
private bool DrawDetailsMaterials() { bool bChanged = false; HEU_PipelineType pipeline = HEU_RenderingPipelineDefines.GetPipeline(); bool isBuiltInRenderPipeline = pipeline == HEU_PipelineType.BiRP; // Force set UseLegacyShaders to prevent possible locked state if (!isBuiltInRenderPipeline && HEU_PluginSettings.UseLegacyShaders == true) { HEU_PluginSettings.UseLegacyShaders = false; } using (new EditorGUI.DisabledScope(!isBuiltInRenderPipeline)) { bool oldValue = HEU_PluginSettings.UseLegacyShaders; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Use Legacy shaders as default", "Use the legacy shaders in case your device doesn't support shader model 3.0. Only supported for the built-in render pipeline."); if (newValue != oldValue) { HEU_PluginSettings.UseLegacyShaders = newValue; bChanged = true; } } bool isUsingLegacyShaders = HEU_PluginSettings.UseLegacyShaders; using (new EditorGUI.DisabledScope(isUsingLegacyShaders)) { bool oldValue = HEU_PluginSettings.UseSpecularShader; bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Use Specular shader as default", "Use the specular workflow instead of the metallic one."); if (newValue != oldValue) { HEU_PluginSettings.UseSpecularShader = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); return bChanged; }
public override void OnInspectorGUI() { serializedObject.Update(); SerializedProperty uiLockedProperty = HEU_EditorUtility.GetSerializedProperty(serializedObject, "_uiLocked"); if (uiLockedProperty != null) { EditorGUI.BeginChangeCheck(); HEU_EditorUI.DrawSeparator(); GUIStyle labelStyle = new GUIStyle(GUI.skin.label); labelStyle.fontStyle = FontStyle.Bold; labelStyle.wordWrap = true; labelStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.yellow : Color.blue; string lockMsg = "This contains the meta data for the HDA." + "\nIt is locked out because it is not recommended to edit it."; EditorGUILayout.LabelField(lockMsg, labelStyle); HEU_EditorUI.DrawSeparator(); uiLockedProperty.boolValue = EditorGUILayout.Toggle("UI Locked", uiLockedProperty.boolValue); if (EditorGUI.EndChangeCheck()) { serializedObject.ApplyModifiedProperties(); } HEU_EditorUI.DrawHorizontalLine(); using (new EditorGUI.DisabledScope(uiLockedProperty.boolValue)) { // Only draw the default if user has unlocked asset UI. DrawDefaultInspector(); } } }
/// <summary> /// Draw the Generate section. /// </summary> private static bool DrawGenerateSection(HEU_HoudiniAssetRoot assetRoot, SerializedObject assetRootSerializedObject, HEU_HoudiniAsset asset, SerializedObject assetObject) { bool bSkipDrawing = false; float separatorDistance = 5f; float screenWidth = EditorGUIUtility.currentViewWidth; float buttonHeight = 30f; float widthPadding = 55f; float doubleButtonWidth = Mathf.Round(screenWidth - widthPadding + separatorDistance); float singleButtonWidth = Mathf.Round((screenWidth - widthPadding) * 0.5f); GUIStyle buttonStyle = new GUIStyle(GUI.skin.button); buttonStyle.fontStyle = FontStyle.Bold; buttonStyle.fontSize = 11; buttonStyle.alignment = TextAnchor.MiddleLeft; buttonStyle.fixedHeight = buttonHeight; buttonStyle.padding.left = 6; buttonStyle.padding.right = 6; buttonStyle.margin.left = 0; buttonStyle.margin.right = 0; GUIStyle centredButtonStyle = new GUIStyle(buttonStyle); centredButtonStyle.alignment = TextAnchor.MiddleCenter; GUIStyle buttonSetStyle = new GUIStyle(GUI.skin.box); RectOffset br = buttonSetStyle.margin; br.left = 4; br.right = 4; buttonSetStyle.margin = br; GUIStyle boxStyle = new GUIStyle(GUI.skin.GetStyle("ColorPickerBackground")); br = boxStyle.margin; br.left = 4; br.right = 4; boxStyle.margin = br; boxStyle.padding = br; GUIStyle promptButtonStyle = new GUIStyle(GUI.skin.button); promptButtonStyle.fontSize = 11; promptButtonStyle.alignment = TextAnchor.MiddleCenter; promptButtonStyle.fixedHeight = 30; promptButtonStyle.margin.left = 34; promptButtonStyle.margin.right = 34; _recookhdaContent.text = " Recook Asset"; HEU_HoudiniAsset.AssetBuildAction pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.NONE; SerializedProperty pendingBuildProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_requestBuildAction"); if (pendingBuildProperty != null) { pendingBuildAction = (HEU_HoudiniAsset.AssetBuildAction)pendingBuildProperty.enumValueIndex; } // Track changes for the build and bake targets EditorGUI.BeginChangeCheck(); HEU_HoudiniAsset.AssetCookStatus cookStatus = GetCookStatusFromSerializedAsset(assetObject); if (cookStatus == HEU_HoudiniAsset.AssetCookStatus.SELECT_SUBASSET) { // Prompt user to select subasset GUIStyle promptStyle = new GUIStyle(GUI.skin.label); promptStyle.fontStyle = FontStyle.Bold; promptStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.green : Color.blue; EditorGUILayout.LabelField("SELECT AN ASSET TO INSTANTIATE:", promptStyle); EditorGUILayout.Separator(); int selectedIndex = -1; string[] subassetNames = asset.SubassetNames; for (int i = 0; i < subassetNames.Length; ++i) { if (GUILayout.Button(subassetNames[i], promptButtonStyle)) { selectedIndex = i; break; } EditorGUILayout.Separator(); } if (selectedIndex >= 0) { SerializedProperty selectedIndexProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_selectedSubassetIndex"); if (selectedIndexProperty != null) { selectedIndexProperty.intValue = selectedIndex; } } bSkipDrawing = true; } else { HEU_EditorUI.BeginSection(); { if (cookStatus == HEU_HoudiniAsset.AssetCookStatus.COOKING || cookStatus == HEU_HoudiniAsset.AssetCookStatus.POSTCOOK) { _recookhdaContent.text = " Cooking Asset"; } else if (cookStatus == HEU_HoudiniAsset.AssetCookStatus.LOADING || cookStatus == HEU_HoudiniAsset.AssetCookStatus.POSTLOAD) { _reloadhdaContent.text = " Loading Asset"; } SerializedProperty showGenerateProperty = assetObject.FindProperty("_showGenerateSection"); showGenerateProperty.boolValue = HEU_EditorUI.DrawFoldOut(showGenerateProperty.boolValue, "GENERATE"); if (showGenerateProperty.boolValue) { //bool bHasPendingAction = (pendingBuildAction != HEU_HoudiniAsset.AssetBuildAction.NONE) || (cookStatus != HEU_HoudiniAsset.AssetCookStatus.NONE); HEU_EditorUI.DrawSeparator(); //EditorGUI.BeginDisabledGroup(bHasPendingAction); using (var hs = new EditorGUILayout.HorizontalScope(boxStyle)) { if (GUILayout.Button(_reloadhdaContent, buttonStyle, GUILayout.Width(singleButtonWidth))) { pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.RELOAD; bSkipDrawing = true; } GUILayout.Space(separatorDistance); if (!bSkipDrawing && GUILayout.Button(_recookhdaContent, buttonStyle, GUILayout.Width(singleButtonWidth))) { pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.COOK; bSkipDrawing = true; } } using (var hs = new EditorGUILayout.HorizontalScope(boxStyle)) { float tripleButtonWidth = Mathf.Round((screenWidth - widthPadding) * 0.33f); if (GUILayout.Button(_removeheContent, buttonStyle, GUILayout.Width(tripleButtonWidth))) { pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.STRIP_HEDATA; bSkipDrawing = true; } GUILayout.Space(separatorDistance); if (GUILayout.Button(_duplicateContent, buttonStyle, GUILayout.Width(tripleButtonWidth))) { pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.DUPLICATE; bSkipDrawing = true; } GUILayout.Space(separatorDistance); if (GUILayout.Button(_resetParamContent, buttonStyle, GUILayout.Width(tripleButtonWidth))) { pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.RESET_PARAMS; bSkipDrawing = true; } } //EditorGUI.EndDisabledGroup(); HEU_EditorUI.DrawSeparator(); } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); HEU_EditorUI.BeginSection(); { SerializedProperty showBakeProperty = assetObject.FindProperty("_showBakeSection"); showBakeProperty.boolValue = HEU_EditorUI.DrawFoldOut(showBakeProperty.boolValue, "BAKE"); if (showBakeProperty.boolValue) { if (!bSkipDrawing) { // Bake -> New Instance, New Prefab, Existing instance or prefab using (var vs = new EditorGUILayout.HorizontalScope(boxStyle)) { if (GUILayout.Button(_bakegameobjectContent, buttonStyle, GUILayout.Width(singleButtonWidth))) { asset.BakeToNewStandalone(); } GUILayout.Space(separatorDistance); if (GUILayout.Button(_bakeprefabContent, buttonStyle, GUILayout.Width(singleButtonWidth))) { asset.BakeToNewPrefab(); } } HEU_EditorUI.DrawSeparator(); using (var hs2 = new EditorGUILayout.VerticalScope(boxStyle)) { if (GUILayout.Button(_bakeandreplaceContent, centredButtonStyle, GUILayout.Width(doubleButtonWidth))) { if (assetRoot._bakeTargets == null || assetRoot._bakeTargets.Count == 0) { // No bake target means user probably forgot to set one. So complain! HEU_EditorUtility.DisplayDialog("No Bake Targets", "Bake Update requires atleast one valid GameObject.\n\nDrag a GameObject or Prefab onto the Drag and drop GameObjects / Prefabs field!", "OK"); } else { int numTargets = assetRoot._bakeTargets.Count; for (int i = 0; i < numTargets; ++i) { GameObject bakeGO = assetRoot._bakeTargets[i]; if (bakeGO != null) { if (HEU_EditorUtility.IsPrefabAsset(bakeGO)) { // Prefab asset means its the source prefab, and not an instance of it asset.BakeToExistingPrefab(bakeGO); } else { // This is for all standalone (including prefab instances) asset.BakeToExistingStandalone(bakeGO); } } else { Debug.LogWarning("Unable to bake to null target at index " + i); } } } } using (var hs = new EditorGUILayout.VerticalScope(buttonSetStyle)) { SerializedProperty bakeTargetsProp = assetRootSerializedObject.FindProperty("_bakeTargets"); if (bakeTargetsProp != null) { EditorGUILayout.PropertyField(bakeTargetsProp, _dragAndDropField, true, GUILayout.Width(doubleButtonWidth - 9f)); } } } } } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); if (pendingBuildAction != HEU_HoudiniAsset.AssetBuildAction.NONE) { // Sanity check to make sure the asset is part of the AssetUpater HEU_AssetUpdater.AddAssetForUpdate(asset); // Apply pending build action based on user UI interaction above pendingBuildProperty.enumValueIndex = (int)pendingBuildAction; if (pendingBuildAction == HEU_HoudiniAsset.AssetBuildAction.COOK) { // Recook should only update parameters that haven't changed. Otherwise if not checking and updating parameters, // then buttons will trigger callbacks on Recook which is not desired. SerializedProperty checkParameterChange = HEU_EditorUtility.GetSerializedProperty(assetObject, "_checkParameterChangeForCook"); if (checkParameterChange != null) { checkParameterChange.boolValue = true; } } } } if (EditorGUI.EndChangeCheck()) { assetRootSerializedObject.ApplyModifiedProperties(); assetObject.ApplyModifiedProperties(); } return bSkipDrawing; }
/// <summary> /// Draw asset options for given asset. /// </summary> /// <param name="asset">The HDA asset</param> /// <param name="assetObject">Serialized HDA asset object</param> private void DrawAssetOptions(HEU_HoudiniAsset asset, SerializedObject assetObject) { GUIStyle buttonStyle = new GUIStyle(GUI.skin.button); buttonStyle.fontSize = 11; buttonStyle.alignment = TextAnchor.MiddleCenter; buttonStyle.fixedHeight = 24; buttonStyle.margin.left = 34; HEU_EditorUI.BeginSection(); { SerializedProperty showHDAOptionsProperty = assetObject.FindProperty("_showHDAOptions"); showHDAOptionsProperty.boolValue = HEU_EditorUI.DrawFoldOut(showHDAOptionsProperty.boolValue, "ASSET OPTIONS"); if (showHDAOptionsProperty.boolValue) { EditorGUI.indentLevel++; HEU_EditorUI.DrawPropertyField(assetObject, "_autoCookOnParameterChange", "Auto-Cook On Parameter Change", "Automatically cook when a parameter changes. If off, must use Recook to cook."); HEU_EditorUI.DrawPropertyField(assetObject, "_pushTransformToHoudini", "Push Transform To Houdini", "Send the asset's transform to Houdini and apply to object."); HEU_EditorUI.DrawPropertyField(assetObject, "_transformChangeTriggersCooks", "Transform Change Triggers Cooks", "Changing the transform (e.g. moving) the asset in Unity will invoke cook in Houdini."); HEU_EditorUI.DrawPropertyField(assetObject, "_cookingTriggersDownCooks", "Cooking Triggers Downstream Cooks", "Cooking this asset will trigger dependent assets' to also cook."); HEU_EditorUI.DrawPropertyField(assetObject, "_generateUVs", "Generate UVs", "Force Unity to generate UVs for output geometry."); HEU_EditorUI.DrawPropertyField(assetObject, "_generateTangents", "Generate Tangents", "Generate tangents in Unity for output geometry."); HEU_EditorUI.DrawPropertyField(assetObject, "_generateNormals", "Generate Normals", "Generate normals in Unity for output geometry."); HEU_EditorUI.DrawPropertyField(assetObject, "_generateMeshUsingPoints", "Generate Mesh Using Points", "Use point attributes instead of vertex attributes for geometry. Ignores vertex attributes."); HEU_EditorUI.DrawPropertyField(assetObject, "_useLODGroups", "Use LOD Groups", "Automatically create Unity LOD group if found."); HEU_EditorUI.DrawPropertyField(assetObject, "_ignoreNonDisplayNodes", "Ignore NonDisplay Nodes", "Only display node geometry will be created."); HEU_EditorUI.DrawPropertyField(assetObject, "_splitGeosByGroup", "Split Geos By Group", "Split geometry into separate gameobjects by group. Deprecated feature and only recommended for simple use cases."); if (asset.NumAttributeStores() > 0) { HEU_EditorUI.DrawPropertyField(assetObject, "_editableNodesToolsEnabled", "Enable Editable Node Tools", "Displays Editable Node Tools and generates the node's geometry, if asset has editable nodes."); } if (asset.NumHandles() > 0) { HEU_EditorUI.DrawPropertyField(assetObject, "_handlesEnabled", "Enable Handles", "Creates Houdini Handles if asset has them."); } EditorGUILayout.Space(); using (var hs = new EditorGUILayout.HorizontalScope()) { if (GUILayout.Button(_savePresetButton, buttonStyle, GUILayout.MaxWidth(160))) { string fileName = asset.AssetName; string filePattern = "preset"; string newPath = EditorUtility.SaveFilePanel("Save HDA preset", "", fileName + "." + filePattern, filePattern); if (newPath != null && !string.IsNullOrEmpty(newPath)) { HEU_AssetPresetUtility.SaveAssetPresetToFile(asset, newPath); } } if (GUILayout.Button(_loadPresetButton, buttonStyle, GUILayout.MaxWidth(160))) { string fileName = asset.AssetName; string filePattern = "preset"; string newPath = EditorUtility.OpenFilePanel("Load HDA preset", "", filePattern); if (newPath != null && !string.IsNullOrEmpty(newPath)) { HEU_AssetPresetUtility.LoadPresetFileIntoAssetAndCook(asset, newPath); } } } EditorGUILayout.Space(); if(GUILayout.Button(_resetMaterialOverridesButton, buttonStyle, GUILayout.MaxWidth(160))) { asset.ResetMaterialOverrides(); } EditorGUI.indentLevel--; } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
/// <summary> /// Draw the Object Instance Inputs section for given asset. /// </summary> /// <param name="asset">The HDA asset</param> /// <param name="assetObject">Serialized HDA asset object</param> private void DrawInstanceInputs(HEU_HoudiniAsset asset, SerializedObject assetObject) { HEU_EditorUI.DrawSeparator(); // Get list of object input fields List<HEU_ObjectInstanceInfo> objInstanceInfos = new List<HEU_ObjectInstanceInfo>(); asset.PopulateObjectInstanceInfos(objInstanceInfos); int numObjInstances = objInstanceInfos.Count; // Display input section if at least have 1 input field if (numObjInstances > 0) { HEU_EditorUI.BeginSection(); SerializedProperty showInstanceInputsProperty = assetObject.FindProperty("_showInstanceInputs"); showInstanceInputsProperty.boolValue = HEU_EditorUI.DrawFoldOut(showInstanceInputsProperty.boolValue, "INSTANCE INPUTS"); if (showInstanceInputsProperty.boolValue) { EditorGUI.BeginChangeCheck(); // Draw each instanced input info for (int i = 0; i < numObjInstances; ++i) { EditorGUILayout.BeginVertical(); string inputName = objInstanceInfos[i]._partTarget.PartName + "_" + i; SerializedObject objInstanceSerialized = new SerializedObject(objInstanceInfos[i]); SerializedProperty instancedInputsProperty = HEU_EditorUtility.GetSerializedProperty(objInstanceSerialized, "_instancedInputs"); if (instancedInputsProperty != null) { int inputCount = instancedInputsProperty.arraySize; EditorGUILayout.PropertyField(instancedInputsProperty, new GUIContent(inputName), true); // When input size increases, Unity creates default values for HEU_InstancedInput which results in // zero value for scale offset. This fixes it up. int newInputCount = instancedInputsProperty.arraySize; if (inputCount < newInputCount) { for (int inputIndex = inputCount; inputIndex < newInputCount; ++inputIndex) { SerializedProperty scaleProperty = instancedInputsProperty.GetArrayElementAtIndex(inputIndex).FindPropertyRelative("_scaleOffset"); scaleProperty.vector3Value = Vector3.one; } } } objInstanceSerialized.ApplyModifiedProperties(); EditorGUILayout.EndVertical(); } if(EditorGUI.EndChangeCheck()) { asset.RequestCook(bCheckParametersChanged: true, bAsync: true, bSkipCookCheck: false, bUploadParameters: true); } } HEU_EditorUI.EndSection(); } }
private bool DrawSessionSettings() { bool bChanged = false; HEU_EditorUI.DrawSeparator(); EditorGUIUtility.labelWidth = 250; { string oldValue = HEU_PluginSettings.Session_PipeName; string newValue = EditorGUILayout.DelayedTextField("Pipe Session Name", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.Session_PipeName = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.Session_Localhost; string newValue = EditorGUILayout.DelayedTextField("Socket Session Host Name", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.Session_Localhost = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { int oldValue = HEU_PluginSettings.Session_Port; int newValue = EditorGUILayout.DelayedIntField("Socket Session Port", oldValue); if (oldValue != newValue) { HEU_PluginSettings.Session_Port = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { float oldValue = HEU_PluginSettings.Session_Timeout; float newValue = EditorGUILayout.DelayedFloatField("Session Timeout", oldValue); if (oldValue != newValue) { HEU_PluginSettings.Session_Timeout = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { bool oldValue = HEU_PluginSettings.Session_AutoClose; bool newValue = EditorGUILayout.Toggle("Session Auto Close", oldValue); if (oldValue != newValue) { HEU_PluginSettings.Session_AutoClose = newValue; bChanged = true; } } EditorGUIUtility.labelWidth = 0; return bChanged; }
public override void OnInspectorGUI() { // Try acquiring asset reference in here again due to Undo. // Eg. After a delete, Undo requires us to re-acquire references. TryAcquiringAsset(); if (_houdiniAsset == null) { DrawNoHDAInfo(); return; } // Always hook into asset UI callback. This could have got reset on code refresh. _houdiniAsset._refreshUIDelegate = RefreshUI; serializedObject.Update(); _houdiniAssetSerializedObject.Update(); bool guiEnabled = GUI.enabled; GUIStyle backgroundStyle = new GUIStyle(GUI.skin.GetStyle("box")); RectOffset br = backgroundStyle.margin; br.top = 10; br.bottom = 6; br.left = 4; br.right = 4; backgroundStyle.margin = br; br = backgroundStyle.padding; br.top = 8; br.bottom = 8; br.left = 8; br.right = 8; backgroundStyle.padding = br; using (var hs = new EditorGUILayout.VerticalScope(backgroundStyle)) { HEU_EditorUI.DrawSeparator(); DrawHeaderSection(); DrawLicenseInfo(); bool bSkipDraw = DrawGenerateSection(_houdiniAssetRoot, serializedObject, _houdiniAsset, _houdiniAssetSerializedObject); ; if (!bSkipDraw) { SerializedProperty assetCookStatusProperty = HEU_EditorUtility.GetSerializedProperty(_houdiniAssetSerializedObject, "_cookStatus"); if (assetCookStatusProperty != null) { // Track changes to Houdini Asset gameobject EditorGUI.BeginChangeCheck(); DrawEventsSection(_houdiniAsset, _houdiniAssetSerializedObject); DrawAssetOptions(_houdiniAsset, _houdiniAssetSerializedObject); DrawCurvesSection(_houdiniAsset, _houdiniAssetSerializedObject); DrawInputNodesSection(_houdiniAsset, _houdiniAssetSerializedObject); DrawTerrainSection(_houdiniAsset, _houdiniAssetSerializedObject); // If this is a Curve asset, we don't need to draw parameters as its redundant if (_houdiniAsset.AssetType != HEU_HoudiniAsset.HEU_AssetType.TYPE_CURVE) { DrawParameters(_houdiniAsset.Parameters, ref _parameterEditor); } DrawInstanceInputs(_houdiniAsset, _houdiniAssetSerializedObject); // Check if any changes occurred, and if so, trigger a recook if (EditorGUI.EndChangeCheck()) { _houdiniAssetSerializedObject.ApplyModifiedProperties(); serializedObject.ApplyModifiedProperties(); // Do recook if values have changed if (HEU_PluginSettings.CookingEnabled && _houdiniAsset.AutoCookOnParameterChange && _houdiniAsset.DoesAssetRequireRecook()) { _houdiniAsset.RequestCook(bCheckParametersChanged: true, bAsync: false, bSkipCookCheck: false, bUploadParameters: true); } } } } } GUI.enabled = guiEnabled; }
private void DrawTerrainSection(HEU_HoudiniAsset asset, SerializedObject assetObject) { int numVolumes = asset.GetVolumeCacheCount(); if(numVolumes <= 0) { return; } HEU_EditorUI.BeginSection(); { SerializedProperty showTerrainProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_showTerrainSection"); if (showTerrainProperty != null) { showTerrainProperty.boolValue = HEU_EditorUI.DrawFoldOut(showTerrainProperty.boolValue, "TERRAIN"); if (showTerrainProperty.boolValue) { // Draw each volume layer List<HEU_VolumeCache> volumeCaches = asset.GetVolumeCaches(); int numCaches = volumeCaches.Count; for (int i = 0; i < numCaches; ++i) { SerializedObject cacheObjectSerialized = new SerializedObject(volumeCaches[i]); bool bChanged = false; SerializedProperty layersProperty = cacheObjectSerialized.FindProperty("_layers"); if (layersProperty == null || layersProperty.arraySize == 0) { continue; } string heading = string.Format("{0}-{1}:", volumeCaches[i].ObjectName, volumeCaches[i].GeoName); if (HEU_EditorUI.DrawFoldOutSerializedProperty(HEU_EditorUtility.GetSerializedProperty(cacheObjectSerialized, "_uiExpanded"), heading, ref bChanged)) { EditorGUI.indentLevel++; int numlayers = layersProperty.arraySize; for (int j = 0; j < numlayers; ++j) { SerializedProperty layerProperty = layersProperty.GetArrayElementAtIndex(j); if (layerProperty == null) { continue; } string layerName = string.Format("Layer: {0}", layerProperty.FindPropertyRelative("_layerName").stringValue); SerializedProperty uiExpandedProperty = layerProperty.FindPropertyRelative("_uiExpanded"); bool bExpanded = uiExpandedProperty != null ? uiExpandedProperty.boolValue : true; bool bNewExpanded = HEU_EditorUI.DrawFoldOut(bExpanded, layerName); if (uiExpandedProperty != null && bExpanded != bNewExpanded) { bChanged = true; uiExpandedProperty.boolValue = bNewExpanded; } if (!bNewExpanded) { continue; } if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_strength", "Strength", "Amount to multiply the layer values by on import.")) { bChanged = true; } SerializedProperty overrideProperty = layerProperty.FindPropertyRelative("_overrides"); SerializedProperty textureProperty = layerProperty.FindPropertyRelative("_diffuseTexture"); if (textureProperty != null) { Object textureObject = textureProperty.objectReferenceValue; EditorGUILayout.PropertyField(textureProperty, new GUIContent("Diffuse Texture", "Difuse texture used by terrain layer.")); if (textureObject != textureProperty.objectReferenceValue) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.Diffuse); bChanged = true; } HEU_EditorUI.DrawSeparator(); } #if UNITY_2018_3_OR_NEWER SerializedProperty maskTextureProperty = layerProperty.FindPropertyRelative("_maskTexture"); if (maskTextureProperty != null) { Object textureObject = maskTextureProperty.objectReferenceValue; EditorGUILayout.PropertyField(maskTextureProperty, new GUIContent("Mask Texture", "The mask map texture used by the terrain layer.")); if (textureObject != maskTextureProperty.objectReferenceValue) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.Mask); bChanged = true; } HEU_EditorUI.DrawSeparator(); } #endif SerializedProperty normalProperty = layerProperty.FindPropertyRelative("_normalTexture"); if (normalProperty != null) { Object normalObject = normalProperty.objectReferenceValue; EditorGUILayout.PropertyField(normalProperty, new GUIContent("NormalMap", "Normal map of the splat applied to the Terrain.")); if (normalObject != normalProperty.objectReferenceValue) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.Normal); bChanged = true; } HEU_EditorUI.DrawSeparator(); } #if UNITY_2018_3_OR_NEWER if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_normalScale", "Normal Scale", "The normal scale value of the splat layer.")) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.NormalScale); bChanged = true; } #endif if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_metallic", "Metallic", "The metallic value of the splat layer.")) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.Metallic); bChanged = true; } if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_smoothness", "Smoothness", "The smoothness value of the splat layer when the main texture has no alpha channel.")) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.Smoothness); bChanged = true; } #if UNITY_2018_3_OR_NEWER SerializedProperty specularProperty = layerProperty.FindPropertyRelative("_specularColor"); if (specularProperty != null) { Color specColor = specularProperty.colorValue; EditorGUILayout.PropertyField(specularProperty, new GUIContent("Specular", "Specular color")); if (specularProperty.colorValue != specColor) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.Specular); bChanged = true; } } #endif if (HEU_EditorUtility.EditorDrawVector2RelativeProperty(layerProperty, "_tileSize", "Tile Size (W, H)", "Size of the tile used in the texture of the SplatPrototype.")) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.TileSize); bChanged = true; } if (HEU_EditorUtility.EditorDrawVector2RelativeProperty(layerProperty, "_tileOffset", "Tile Offset (X, Y)", "Offset of the tile texture of the SplatPrototype.")) { SetVolumeLayerPropertyOverride(overrideProperty, HEU_VolumeLayer.Overrides.TileOffset); bChanged = true; } HEU_EditorUI.DrawSeparator(); } EditorGUI.indentLevel--; } if(bChanged) { SerializedProperty dirtyProperty = cacheObjectSerialized.FindProperty("_isDirty"); if (dirtyProperty != null) { dirtyProperty.boolValue = true; } cacheObjectSerialized.ApplyModifiedProperties(); } } } } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
public void OnGUI() { if (!_initializedUI) { // Creating of UI elements must happen in OnGUI InitializeUIElements(); } bool bChanged = false; Color originalBGColor = GUI.backgroundColor; bool bRequiresLoad = !HEU_ShelfTools.AreShelvesLoaded(); if(!bRequiresLoad) { // Sanity check that textures are still valid. When scene changes, these get invalidated. if (_guiContents != null && _guiContents.Length > 0) { bRequiresLoad = (_guiContents[0].image == null); } } if(bRequiresLoad) { LoadShelves(); } int numTools = 0; using (new EditorGUILayout.VerticalScope()) { using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) { if (HEU_ShelfTools.AreShelvesLoaded()) { int currentShelfIndex = HEU_ShelfTools.GetCurrentShelfIndex(); HEU_Shelf shelf = null; using (new EditorGUILayout.HorizontalScope()) { GUILayout.FlexibleSpace(); if (GUILayout.Button(_addButton, _buttonStyle, GUILayout.MaxWidth(_buttonWidth), GUILayout.MaxHeight(_buttonHeight))) { string newShelfPath = UnityEditor.EditorUtility.OpenFolderPanel("Add Shelf Folder", "", ""); if (!string.IsNullOrEmpty(newShelfPath) && HEU_Platform.DoesDirectoryExist(newShelfPath)) { AddNewShelfWindow(newShelfPath); bChanged = true; } } } using (new EditorGUILayout.HorizontalScope()) { GUILayout.Label("Active Shelf"); int newShelfIndex = EditorGUILayout.Popup(currentShelfIndex, _shelfNames, _popupStyle); if (currentShelfIndex != newShelfIndex) { // Change shelf currentShelfIndex = newShelfIndex; HEU_ShelfTools.SetCurrentShelf(currentShelfIndex); SelectShelf(currentShelfIndex); } shelf = HEU_ShelfTools.GetShelf(currentShelfIndex); numTools = shelf._tools.Count; using (new EditorGUI.DisabledGroupScope(shelf._defaultShelf)) { if (GUILayout.Button(_removeButton, _buttonStyle, GUILayout.MaxWidth(_buttonWidth))) { HEU_ShelfTools.RemoveShelf(currentShelfIndex); HEU_ShelfTools.SaveShelf(); HEU_ShelfTools.SetReloadShelves(); bChanged = true; } } } HEU_EditorUI.DrawSeparator(); if (!bChanged) { using (EditorGUILayout.ScrollViewScope scroll = new EditorGUILayout.ScrollViewScope(_toolButtonScrollPos)) { if (numTools > 0) { int numXElements = numTools < _toolGridXElements ? numTools : _toolGridXElements; _selectedToolIndex = GUILayout.SelectionGrid(_selectedToolIndex, _guiContents, numXElements, _toolGridStyle); } else { EditorGUILayout.LabelField("No tools found!"); } _toolButtonScrollPos = scroll.scrollPosition; } } } } bool bValidSelection = (_selectedToolIndex >= 0 && _selectedToolIndex < numTools); using (new EditorGUI.DisabledGroupScope(!bValidSelection)) { if(!bValidSelection) { _applyButton.text = "Select a Tool!"; } else { GameObject[] selectedObjects = HEU_EditorUtility.GetSelectedObjects(); if(selectedObjects.Length == 0) { _applyButton.text = "Create Tool (no input selected)!"; } else { _applyButton.text = "Create Tool (selected objects as inputs)!"; } } if (GUILayout.Button(_applyButton, _buttonStyle, GUILayout.MaxHeight(_buttonHeight))) { ProcessUserSelection(_selectedToolIndex); } } } }
private void DrawTerrainSection(HEU_HoudiniAsset asset, SerializedObject assetObject) { int numVolumes = asset.GetVolumeCacheCount(); if(numVolumes <= 0) { return; } HEU_EditorUI.BeginSection(); { SerializedProperty showTerrainProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_showTerrainSection"); if (showTerrainProperty != null) { showTerrainProperty.boolValue = HEU_EditorUI.DrawFoldOut(showTerrainProperty.boolValue, "TERRAIN"); if (showTerrainProperty.boolValue) { // Draw each volume layer List<HEU_VolumeCache> volumeCaches = asset.GetVolumeCaches(); int numCaches = volumeCaches.Count; for (int i = 0; i < numCaches; ++i) { SerializedObject cacheObjectSerialized = new SerializedObject(volumeCaches[i]); bool bChanged = false; bool bStrengthChanged = false; SerializedProperty layersProperty = cacheObjectSerialized.FindProperty("_layers"); if (layersProperty == null || layersProperty.arraySize == 0) { continue; } string heading = string.Format("{0}-{1}:", volumeCaches[i].ObjectName, volumeCaches[i].GeoName); if (HEU_EditorUI.DrawFoldOutSerializedProperty(HEU_EditorUtility.GetSerializedProperty(cacheObjectSerialized, "_uiExpanded"), heading, ref bChanged)) { EditorGUI.indentLevel++; int numlayers = layersProperty.arraySize; for (int j = 0; j < numlayers; ++j) { SerializedProperty layerProperty = layersProperty.GetArrayElementAtIndex(j); if (layerProperty == null) { continue; } // Skipping "height" layer on UI since its treated as Houdini-specific layer string layerName = layerProperty.FindPropertyRelative("_layerName").stringValue; if (layerName.Equals(HEU_Defines.HAPI_HEIGHTFIELD_LAYERNAME_HEIGHT)) { continue; } layerName = string.Format("Layer: {0}", layerName); SerializedProperty uiExpandedProperty = layerProperty.FindPropertyRelative("_uiExpanded"); bool bExpanded = uiExpandedProperty != null ? uiExpandedProperty.boolValue : true; bool bNewExpanded = HEU_EditorUI.DrawFoldOut(bExpanded, layerName); if (uiExpandedProperty != null && bExpanded != bNewExpanded) { bChanged = true; uiExpandedProperty.boolValue = bNewExpanded; } if (!bNewExpanded) { continue; } if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_strength", "Strength", "Amount to multiply the layer values by on import.")) { bStrengthChanged = true; } HEU_EditorUI.DrawSeparator(); } EditorGUI.indentLevel--; } if (bStrengthChanged) { SerializedProperty dirtyProperty = cacheObjectSerialized.FindProperty("_isDirty"); if (dirtyProperty != null) { dirtyProperty.boolValue = true; bChanged = true; } } if(bChanged) { cacheObjectSerialized.ApplyModifiedProperties(); } } } } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
private void DrawCurvesSection(HEU_HoudiniAsset asset, SerializedObject assetObject) { if (asset.GetEditableCurveCount() <= 0) { return; } GUIStyle buttonStyle = new GUIStyle(GUI.skin.button); buttonStyle.fontSize = 11; buttonStyle.alignment = TextAnchor.MiddleCenter; buttonStyle.fixedHeight = 24; buttonStyle.margin.left = 34; HEU_EditorUI.BeginSection(); { SerializedProperty showCurvesProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_showCurvesSection"); if (showCurvesProperty != null) { showCurvesProperty.boolValue = HEU_EditorUI.DrawFoldOut(showCurvesProperty.boolValue, "CURVES"); if (showCurvesProperty.boolValue) { SerializedProperty curveEditorProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_curveEditorEnabled"); if (curveEditorProperty != null) { EditorGUILayout.PropertyField(curveEditorProperty); } HEU_EditorUI.DrawHeadingLabel("Collision Settings"); EditorGUI.indentLevel++; string projectLabel = "Project Curves To "; List<HEU_Curve> curves = asset.GetCurves(); SerializedProperty curveCollisionProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_curveDrawCollision"); if (curveCollisionProperty != null) { EditorGUILayout.PropertyField(curveCollisionProperty, new GUIContent("Collision Type")); if (curveCollisionProperty.enumValueIndex == (int)HEU_Curve.CurveDrawCollision.COLLIDERS) { HEU_EditorUtility.EditorDrawSerializedProperty(assetObject, "_curveDrawColliders", label: "Colliders"); projectLabel += "Colliders"; } else if (curveCollisionProperty.enumValueIndex == (int)HEU_Curve.CurveDrawCollision.LAYERMASK) { HEU_EditorUtility.EditorDrawSerializedProperty(assetObject, "_curveDrawLayerMask", label: "Layer Mask"); projectLabel += "Layer"; } HEU_EditorUI.DrawSeparator(); EditorGUI.indentLevel--; HEU_EditorUI.DrawHeadingLabel("Projection Settings"); EditorGUI.indentLevel++; HEU_EditorUtility.EditorDrawSerializedProperty(assetObject, "_curveProjectDirection", label: "Project Direction", tooltip: "The ray cast direction for projecting the curve points."); HEU_EditorUtility.EditorDrawFloatProperty(assetObject, "_curveProjectMaxDistance", label: "Project Max Distance", tooltip: "The maximum ray cast distance for projecting the curve points."); _projectCurvePointsButton.text = projectLabel; if (GUILayout.Button(_projectCurvePointsButton, buttonStyle, GUILayout.MaxWidth(180))) { SerializedProperty projectDirProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_curveProjectDirection"); SerializedProperty maxDistanceProperty = HEU_EditorUtility.GetSerializedProperty(assetObject, "_curveProjectMaxDistance"); Vector3 projectDir = projectDirProperty != null ? projectDirProperty.vector3Value : Vector3.down; float maxDistance = maxDistanceProperty != null ? maxDistanceProperty.floatValue : 0; for (int i = 0; i < curves.Count; ++i) { curves[i].ProjectToColliders(asset, projectDir, maxDistance); } } } EditorGUI.indentLevel--; HEU_EditorUI.DrawSeparator(); for (int i = 0; i < curves.Count; ++i) { if (curves[i].Parameters != null) { DrawParameters(curves[i].Parameters, ref _curveParameterEditor); } } } } } HEU_EditorUI.EndSection(); HEU_EditorUI.DrawSeparator(); }
private bool DrawAdvancedSettings() { bool bChanged = false; GUIStyle labelStyle = new GUIStyle(GUI.skin.label); labelStyle.normal.textColor = HEU_EditorUI.GetUISafeTextColorYellow(); EditorGUILayout.LabelField("Warning: Changing these values from default might result in HDAs not loading properly!", labelStyle, GUILayout.MinHeight(30)); HEU_EditorUI.DrawSeparator(); EditorGUIUtility.labelWidth = 250; { string oldValue = HEU_PluginSettings.HDAData_Name; string newValue = EditorGUILayout.DelayedTextField("HDA Data GameObject Name", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.HDAData_Name = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.EditorOnly_Tag; string newValue = EditorGUILayout.DelayedTextField("HDA Data GameObject Tag", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.EditorOnly_Tag = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.CollisionGroupName; string newValue = EditorGUILayout.DelayedTextField("Collision Group", oldValue); if(oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.CollisionGroupName = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.RenderedCollisionGroupName; string newValue = EditorGUILayout.DelayedTextField("Rendered Collision Group", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.RenderedCollisionGroupName = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.UnityMaterialAttribName; string newValue = EditorGUILayout.DelayedTextField("Unity Material Attribute", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.UnityMaterialAttribName = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.UnitySubMaterialAttribName; string newValue = EditorGUILayout.DelayedTextField("Unity Substance Material Attribute", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.UnitySubMaterialAttribName = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.UnityTagAttributeName; string newValue = EditorGUILayout.DelayedTextField("Unity Tag Attribute", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.UnityTagAttributeName = newValue; bChanged = true; } } HEU_EditorUI.DrawSeparator(); { string oldValue = HEU_PluginSettings.UnityScriptAttributeName; string newValue = EditorGUILayout.DelayedTextField("Unity Script Attribute", oldValue); if (oldValue != newValue && !string.IsNullOrEmpty(newValue)) { HEU_PluginSettings.UnityScriptAttributeName = newValue; bChanged = true; } } EditorGUIUtility.labelWidth = 0; return bChanged; }
/// <summary> /// Draw the given asset's input instances. /// Caches initially, then draws in paginized format. /// </summary> /// <param name="asset">Asset's input instances to draw</param> /// <param name="assetObject">Serialized object of assset</param> public void DrawInstanceInputs(HEU_HoudiniAsset asset, SerializedObject assetObject) { if (!_populated) { // Create cache PopulateInstanceInputCache(asset, assetObject); } if (_instanceObjects.Count == 0) { //Debug.Log("No instance objects"); return; } HEU_EditorUI.DrawSeparator(); int numObjInstances = _instanceObjects.Count; // Display input section if at least have 1 input field if (numObjInstances > 0) { HEU_EditorUI.BeginSection(); EditorGUI.BeginChangeCheck(); _showInstanceInputsProperty.boolValue = HEU_EditorUI.DrawFoldOut (_showInstanceInputsProperty.boolValue, "INSTANCE INPUTS"); if (EditorGUI.EndChangeCheck()) { // Only apply change to the UI object so don't need to cook entire asset _serializedObject.ApplyModifiedProperties(); } if (_showInstanceInputsProperty.boolValue) { EditorGUI.BeginChangeCheck(); // Number to display per page EditorGUILayout.DelayedIntField(_numInputsToShowProperty, new GUIContent("Display Per Page")); int numInputsToShow = Mathf.Clamp(_numInputsToShowProperty.intValue, 1, numObjInstances); _numInputsToShowProperty.intValue = numInputsToShow; int inputsPageIndex = _inputsPageIndexProperty.intValue; int totalPages = numObjInstances / numInputsToShow; using (new GUILayout.HorizontalScope()) { EditorGUILayout.DelayedIntField(_inputsPageIndexProperty, new GUIContent("Page")); // Current page inputsPageIndex = Mathf.Clamp(_inputsPageIndexProperty.intValue, 0, totalPages - 1); // Previous page EditorGUI.BeginDisabledGroup(inputsPageIndex <= 0); if (GUILayout.Button("<<")) { inputsPageIndex--; } EditorGUI.EndDisabledGroup(); // Next page EditorGUI.BeginDisabledGroup(inputsPageIndex >= (totalPages - 1)); if (GUILayout.Button(">>")) { inputsPageIndex++; } EditorGUI.EndDisabledGroup(); _inputsPageIndexProperty.intValue = inputsPageIndex; } inputsPageIndex = inputsPageIndex < totalPages ? inputsPageIndex : totalPages - 1; int startIndex = inputsPageIndex * numInputsToShow; int validNumInputs = numInputsToShow <= numObjInstances ? numInputsToShow : numObjInstances; if (EditorGUI.EndChangeCheck()) { // Only apply change to the UI object so don't need to cook entire asset _serializedObject.ApplyModifiedProperties(); } EditorGUI.BeginChangeCheck(); // Draw instanced input info for current page for (int i = 0; i < validNumInputs; ++i) { EditorGUILayout.BeginVertical(); int currentIndex = startIndex + i; if (_instanceObjects[currentIndex]._instancedInputsProperty != null) { int inputCount = _instanceObjects[currentIndex]._instancedInputsProperty.arraySize; EditorGUILayout.PropertyField(_instanceObjects[currentIndex]._instancedInputsProperty, new GUIContent(_instanceObjects[currentIndex]._inputName), true); // When input size increases, Unity creates default values for HEU_InstancedInput which results in // zero value for scale offset. This fixes it up. int newInputCount = _instanceObjects[currentIndex]._instancedInputsProperty.arraySize; if (inputCount < newInputCount) { for (int inputIndex = inputCount; inputIndex < newInputCount; ++inputIndex) { SerializedProperty scaleProperty = _instanceObjects[currentIndex]._instancedInputsProperty.GetArrayElementAtIndex(inputIndex).FindPropertyRelative("_scaleOffset"); scaleProperty.vector3Value = Vector3.one; } } } _instanceObjects[currentIndex]._objInstanceSerialized.ApplyModifiedProperties(); EditorGUILayout.EndVertical(); } if (EditorGUI.EndChangeCheck()) { asset.RequestCook(bCheckParametersChanged: true, bAsync: true, bSkipCookCheck: false, bUploadParameters: true); } } HEU_EditorUI.EndSection(); } }
public override void OnInspectorGUI() { if (_geoSync == null) { AcquireTarget(); } using (new EditorGUILayout.VerticalScope()) { bool bSyncing = _geoSync.IsSyncing; EditorGUILayout.LabelField(_fileLabelContent); using (new EditorGUILayout.HorizontalScope()) { _geoSync._filePath = EditorGUILayout.DelayedTextField(_geoSync._filePath); // TODO: add field for output cache directory GUIStyle buttonStyle = HEU_EditorUI.GetNewButtonStyle_MarginPadding(0, 0); if (GUILayout.Button("...", buttonStyle, GUILayout.Width(30), GUILayout.Height(18))) { string filePattern = "*.bgeo;*.bgeo.sc"; _geoSync._filePath = EditorUtility.OpenFilePanel("Select File", _geoSync._filePath, filePattern); } } HEU_EditorUI.DrawSeparator(); if (bSyncing) { EditorGUILayout.LabelField(_statusSyncContent); if (GUILayout.Button(_stopContent)) { _geoSync.StopSync(); } } else { EditorGUILayout.LabelField(_statusIdleContent); using (new EditorGUILayout.HorizontalScope()) { bool bLoaded = _geoSync.IsLoaded(); if (GUILayout.Button(_syncContent)) { _geoSync.StartSync(); } //GUILayout.FlexibleSpace(); using (new EditorGUI.DisabledScope(!bLoaded)) { if (GUILayout.Button(_unloadContent)) { _geoSync.Unload(); } } } } if (!string.IsNullOrEmpty(_geoSync._logStr)) { EditorGUILayout.LabelField("Log: " + _geoSync._logStr); } } }