private void DrawViewModeInfo()
		{
			float uiWidth = _editorUIRect.width * _infoPanelSettingsWidth;

			char upArrow = '\u25B2';
			char downArrow = '\u25BC';
			float arrayWidth = 25;

			GUIStyle editNodesBoxStyle = new GUIStyle(GUI.skin.textArea);
			GUIStyle entryStyle = new GUIStyle(GUI.skin.box);

			using (var hs = new EditorGUILayout.HorizontalScope())
			{
				using (var vs = new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.MaxWidth(uiWidth)))
				{
					EditorGUILayout.LabelField("This tool allows to Paint & Edit POINT attributes of Editable nodes.");
					EditorGUILayout.LabelField("Painting vertex colors is directly supported if a Paint SOP is made editable.");
					EditorGUILayout.LabelField("Use node list on the right to re-order editable nodes by order of edit operations.");
					EditorGUILayout.LabelField("Nodes that take inputs from other editable nodes should come after them in the list.");
				}

				using (var vs = new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
				{
					// Draw each editable node (attribute store), along with buttons to re-order the node.

					using (var hs2 = new EditorGUILayout.HorizontalScope())
					{
						HEU_EditorUI.DrawHeadingLabel("EDIT ORDER");

						SerializedProperty cookUpstreamSerializedProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_alwaysCookUpstream");
						if (cookUpstreamSerializedProperty != null)
						{
							EditorGUILayout.PropertyField(cookUpstreamSerializedProperty,
								new GUIContent("Always Cook Inputs", "For multiple editable nodes, this forces each one to always cook upstream inputs first before applying edits."),
								GUILayout.Width(168));
						}
					}

					using (var vs2 = new EditorGUILayout.VerticalScope(editNodesBoxStyle))
					{
						using (var scrollScope = new EditorGUILayout.ScrollViewScope(_editNodeScrollPos))
						{
							_editNodeScrollPos = scrollScope.scrollPosition;

							int numStores = _attributesStores.Count;
							for (int i = 0; i < numStores; ++i)
							{
								using (var hsi = new EditorGUILayout.HorizontalScope(entryStyle))
								{
									if (GUILayout.Button(upArrow.ToString(), GUILayout.MaxWidth(arrayWidth)))
									{
										if (i > 0)
										{
											_asset.ReorderAttributeStore(i, i - 1);
										}
									}

									if (GUILayout.Button(downArrow.ToString(), GUILayout.MaxWidth(arrayWidth)))
									{
										if (i < numStores - 1)
										{
											_asset.ReorderAttributeStore(i, i + 1);
										}
									}

									EditorGUILayout.LabelField(_attributesStores[i].GeoName);
								}
							}

						}
					}
				}
			}
		}
Exemplo n.º 2
0
		/// <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))
						{
							if (GUILayout.Button(_removeheContent, buttonStyle, GUILayout.Width(singleButtonWidth)))
							{
								pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.STRIP_HEDATA;
								bSkipDrawing = true;
							}

							GUILayout.Space(separatorDistance);

							if (GUILayout.Button(_duplicateContent, buttonStyle, GUILayout.Width(singleButtonWidth)))
							{
								pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.DUPLICATE;
								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.IsPrefabOriginal(bakeGO))
												{
													// Prefab original means its true prefab, and not an instance of it
													// TODO: allow user to cancel
													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)
					{
						// Forcing recook without checking for changes allows users to do a semi-reset on the output, 
						// without needing to reload (loose changes) or change parameter then undo.
						SerializedProperty checkParameterChange = HEU_EditorUtility.GetSerializedProperty(assetObject, "_checkParameterChangeForCook");
						if (checkParameterChange != null)
						{
							checkParameterChange.boolValue = false;
						}
					}
				}
			}
			
			if (EditorGUI.EndChangeCheck())
			{
				assetRootSerializedObject.ApplyModifiedProperties();
				assetObject.ApplyModifiedProperties();
			}

			return bSkipDrawing;
		}
Exemplo n.º 3
0
	public bool DrawHandles(HEU_HoudiniAsset asset)
	{
	    List<HEU_Handle> handles = CacheHandles();

	    HEU_HandleManipMode manipMode = GetCurrentGlobalManipMode();

	    GUIStyle textStyle = new GUIStyle(EditorStyles.textField);
	    textStyle.contentOffset = new Vector2(1.4f, 1.4f);

	    HEU_Parameters assetParameters = asset.Parameters;
	    SerializedObject serializedParametersObject = new SerializedObject(assetParameters);
	    SerializedProperty parameterListProperty = HEU_EditorUtility.GetSerializedProperty(serializedParametersObject, "_parameterList");

	    bool bChanged = false;

	    Matrix4x4 defaultMatrix = Handles.matrix;

	    foreach (HEU_Handle handle in handles)
	    {
		if (handle.HandleType == HEU_Handle.HEU_HandleType.XFORM)
		{
		    Handles.matrix = asset.transform.localToWorldMatrix;

		    Vector3 handlePosition = handle.HandlePosition;
		    Quaternion handleRotation = handle.HandleRotation;
		    Vector3 handleScale = handle.HandleScale;

		    string handleName = handle.HandleName;

		    if (manipMode == HEU_HandleManipMode.MOVE)
		    {
			if (!handle.HasTranslateHandle())
			{
			    continue;
			}

			bool bDisabled = handle.IsTranslateHandleDisabled();
			if (bDisabled)
			{
			    handleName += " (disabled)";
			}

			GUIContent labelContent = new GUIContent(handleName);
			labelContent.tooltip = handleName;

			Handles.Label(handlePosition, labelContent, textStyle);

			if (bDisabled)
			{
			    bool bLighting = Handles.lighting;
			    Handles.lighting = false;
			    Handles.PositionHandle(handlePosition, handleRotation);
			    Handles.lighting = bLighting;
			    continue;
			}

			Vector3 updatedPosition = Handles.PositionHandle(handlePosition, handleRotation);
			if (updatedPosition != handlePosition)
			{
			    if (!handle.GetUpdatedPosition(asset, ref updatedPosition))
			    {
				continue;
			    }

			    HEU_HandleParamBinding translateBinding = handle.GetTranslateBinding();
			    if (translateBinding != null)
			    {
				HEU_ParameterData paramData = assetParameters.GetParameterWithParmID(translateBinding._parmID);
				if (paramData != null && paramData._unityIndex < parameterListProperty.arraySize)
				{
				    SerializedProperty paramDataProperty = parameterListProperty.GetArrayElementAtIndex(paramData._unityIndex);
				    float[] posFloats = new float[3];
				    posFloats[0] = updatedPosition[0];
				    posFloats[1] = updatedPosition[1];
				    posFloats[2] = updatedPosition[2];
				    bChanged |= UpdateFloatArrayProperty(paramDataProperty, posFloats, translateBinding);
				}
			    }
			}
		    }
		    else if (manipMode == HEU_HandleManipMode.ROTATE)
		    {
			if (!handle.HasRotateHandle())
			{
			    continue;
			}

			bool bDisabled = handle.IsRotateHandleDisabled();
			if (bDisabled)
			{
			    handleName += " (disabled)";
			}

			GUIContent labelContent = new GUIContent(handleName);
			labelContent.tooltip = handleName;

			Handles.Label(handlePosition, labelContent, textStyle);

			if (bDisabled)
			{
			    bool bLighting = Handles.lighting;
			    Handles.lighting = false;
			    Handles.RotationHandle(handleRotation, handlePosition);
			    Handles.lighting = bLighting;
			    continue;
			}

			Quaternion updatedRotation = Handles.RotationHandle(handleRotation, handlePosition);
			if (updatedRotation != handleRotation)
			{
			    if (!handle.GetUpdatedRotation(asset, ref updatedRotation))
			    {
				continue;
			    }

			    HEU_HandleParamBinding rotateBinding = handle.GetRotateBinding();
			    if (rotateBinding != null)
			    {
				HEU_ParameterData paramData = assetParameters.GetParameterWithParmID(rotateBinding._parmID);
				if (paramData != null && paramData._unityIndex < parameterListProperty.arraySize)
				{
				    SerializedProperty paramDataProperty = parameterListProperty.GetArrayElementAtIndex(paramData._unityIndex);
				    float[] rotFloats = new float[3];
				    rotFloats[0] = updatedRotation[0];
				    rotFloats[1] = updatedRotation[1];
				    rotFloats[2] = updatedRotation[2];
				    bChanged |= UpdateFloatArrayProperty(paramDataProperty, rotFloats, rotateBinding);
				}
			    }
			}
		    }
		    else if (manipMode == HEU_HandleManipMode.SCALE)
		    {
			if (!handle.HasScaleHandle())
			{
			    continue;
			}

			bool bDisabled = handle.IsScaleHandleDisabled();
			if (bDisabled)
			{
			    handleName += " (disabled)";
			}

			GUIContent labelContent = new GUIContent(handleName);
			labelContent.tooltip = handleName;

			Handles.Label(handlePosition, labelContent, textStyle);

			if (bDisabled)
			{
			    bool bLighting = Handles.lighting;
			    Handles.lighting = false;
			    Handles.ScaleHandle(handleScale, handlePosition, handleRotation, 1f);
			    Handles.lighting = bLighting;
			    continue;
			}

			Vector3 updatedScale = Handles.ScaleHandle(handleScale, handlePosition, handleRotation, 1f);
			if (updatedScale != handleScale)
			{
			    HEU_HandleParamBinding scaleBinding = handle.GetScaleBinding();
			    if (scaleBinding != null)
			    {
				HEU_ParameterData paramData = assetParameters.GetParameterWithParmID(scaleBinding._parmID);
				if (paramData != null && paramData._unityIndex < parameterListProperty.arraySize)
				{
				    SerializedProperty paramDataProperty = parameterListProperty.GetArrayElementAtIndex(paramData._unityIndex);
				    float[] scaleFloats = new float[3];
				    scaleFloats[0] = updatedScale[0];
				    scaleFloats[1] = updatedScale[1];
				    scaleFloats[2] = updatedScale[2];
				    bChanged |= UpdateFloatArrayProperty(paramDataProperty, scaleFloats, scaleBinding);
				}
			    }
			}
		    }
		}
	    }

	    if (bChanged)
	    {
		serializedParametersObject.ApplyModifiedProperties();
	    }

	    Handles.matrix = defaultMatrix;

	    return bChanged;
	}
Exemplo n.º 4
0
	public static void ExportAllAssetsGeo()
	{
	    HEU_EditorUtility.ExportAllAssetsToGeoFiles();
	}
Exemplo n.º 5
0
		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);

						// 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())
							{
								bool bCheckParametersChanged = true;
								bool bAsync = false;
								bool bForceCook = false;
								bool bUploadParameters = true;
								_houdiniAsset.RequestCook(bCheckParametersChanged, bAsync, bForceCook, bUploadParameters);
							}
						}
					}
				}
			}

			GUI.enabled = guiEnabled;
		}
Exemplo n.º 6
0
	public static void RebuildAll()
	{
	    HEU_EditorUtility.RebuildAll();
	}
Exemplo n.º 7
0
	public static void BakeAndReplaceAll()
	{
	    HEU_EditorUtility.BakeAndReplaceAllInScene();
	}
Exemplo n.º 8
0
        /// <summary>
        /// Draw the UI for the given input node
        /// </summary>
        /// <param name="inputNode"></param>
        public static void EditorDrawInputNode(HEU_InputNode inputNode)
        {
            int plusButtonWidth = 20;

            //GUIStyle boldLabelStyle = new GUIStyle(EditorStyles.boldLabel);
            //boldLabelStyle.alignment = TextAnchor.UpperLeft;

            GUIContent inputTypeLabel = new GUIContent("Input Type");

            GUIContent translateLabel = new GUIContent("    Translate");
            GUIContent rotateLabel    = new GUIContent("    Rotate");
            GUIContent scaleLabel     = new GUIContent("    Scale");

            PopulateCache(inputNode);

            EditorGUI.BeginChangeCheck();

            EditorGUILayout.BeginVertical(EditorStyles.helpBox);

            string inputName = inputNode.InputName;

            if (!string.IsNullOrEmpty(inputName))
            {
                EditorGUILayout.LabelField(inputName);
            }

            EditorGUI.indentLevel++;

            HEU_InputNode.InputObjectType inputObjectType             = (HEU_InputNode.InputObjectType)inputNode._uiCache._inputObjectTypeProperty.intValue;
            HEU_InputNode.InputObjectType userSelectedInputObjectType = (HEU_InputNode.InputObjectType)EditorGUILayout.EnumPopup(inputTypeLabel, inputObjectType);
            if (userSelectedInputObjectType != inputObjectType)
            {
                SerializedProperty pendingInputObjectTypeProperty = HEU_EditorUtility.GetSerializedProperty(inputNode._uiCache._inputNodeSerializedObject, "_pendingInputObjectType");
                if (pendingInputObjectTypeProperty != null)
                {
                    pendingInputObjectTypeProperty.intValue = (int)userSelectedInputObjectType;
                }
            }
            else
            {
                if (inputObjectType == HEU_InputNode.InputObjectType.HDA)
                {
                    // For input asset, filter out other Component types
                    UnityEngine.Object setObject = EditorGUILayout.ObjectField(inputNode._uiCache._inputAssetProperty.objectReferenceValue, typeof(HEU_HoudiniAssetRoot), true);
                    if (setObject != inputNode._uiCache._inputAssetProperty.objectReferenceValue)
                    {
                        GameObject inputGO = setObject != null ? (setObject as HEU_HoudiniAssetRoot).gameObject : null;
                        // Check not setting same asset as self
                        if (inputGO == null || inputGO != inputNode.ParentAsset.RootGameObject)
                        {
                            inputNode._uiCache._inputAssetProperty.objectReferenceValue = inputGO;
                        }
                    }
                }
                //else if (inputObjectType == HEU_InputNode.InputObjectType.CURVE)
                //{
                //	TODO INPUT CURVE
                //}
                else if (inputObjectType == HEU_InputNode.InputObjectType.UNITY_MESH)
                {
                    EditorGUILayout.PropertyField(inputNode._uiCache._keepWorldTransformProperty);
                    EditorGUILayout.PropertyField(inputNode._uiCache._packBeforeMergeProperty);

                    SerializedProperty inputObjectsProperty = inputNode._uiCache._inputObjectsProperty;
                    if (inputObjectsProperty != null)
                    {
                        int  inputCount    = inputObjectsProperty.arraySize;
                        bool bSkipElements = false;

                        HEU_EditorUI.DrawSeparator();

                        using (var hs1 = new EditorGUILayout.HorizontalScope())
                        {
                            EditorGUILayout.LabelField(string.Format("{0} input objects", inputCount));

                            if (GUILayout.Button("Add"))
                            {
                                inputObjectsProperty.InsertArrayElementAtIndex(inputCount);
                                FixUpScaleProperty(inputObjectsProperty, inputCount);

                                bSkipElements = true;
                            }

                            if (GUILayout.Button("Clear"))
                            {
                                inputObjectsProperty.ClearArray();
                                bSkipElements = true;
                            }
                        }

                        if (!bSkipElements)
                        {
                            using (var vs1 = new EditorGUILayout.VerticalScope())
                            {
                                for (int i = 0; i < inputCount; ++i)
                                {
                                    using (var hs2 = new EditorGUILayout.HorizontalScope())
                                    {
                                        EditorGUILayout.LabelField("Input " + (i + 1));

                                        //using (var vs3 = new EditorGUILayout.VerticalScope())
                                        {
                                            if (GUILayout.Button("+", GUILayout.Width(plusButtonWidth)))
                                            {
                                                inputObjectsProperty.InsertArrayElementAtIndex(i);
                                                FixUpScaleProperty(inputObjectsProperty, i);
                                                break;
                                            }

                                            if (GUILayout.Button("-", GUILayout.Width(plusButtonWidth)))
                                            {
                                                inputObjectsProperty.DeleteArrayElementAtIndex(i);
                                                break;
                                            }
                                        }
                                    }

                                    EditorGUI.indentLevel++;
                                    using (var vs4 = new EditorGUILayout.VerticalScope())
                                    {
                                        HEU_InputNodeUICache.HEU_InputObjectUICache objectCache = inputNode._uiCache._inputObjectCache[i];

                                        EditorGUILayout.PropertyField(objectCache._gameObjectProperty, GUIContent.none);

                                        using (new EditorGUI.DisabledScope(!inputNode._uiCache._keepWorldTransformProperty.boolValue))
                                        {
                                            objectCache._transformOffsetProperty.boolValue = HEU_EditorUI.DrawToggleLeft(objectCache._transformOffsetProperty.boolValue, "Transform Offset");
                                            if (objectCache._transformOffsetProperty.boolValue)
                                            {
                                                objectCache._translateProperty.vector3Value = EditorGUILayout.Vector3Field(translateLabel, objectCache._translateProperty.vector3Value);
                                                objectCache._rotateProperty.vector3Value    = EditorGUILayout.Vector3Field(rotateLabel, objectCache._rotateProperty.vector3Value);
                                                objectCache._scaleProperty.vector3Value     = EditorGUILayout.Vector3Field(scaleLabel, objectCache._scaleProperty.vector3Value);
                                            }
                                        }
                                    }
                                    EditorGUI.indentLevel--;
                                }
                            }
                        }
                    }
                }
            }

            EditorGUI.indentLevel--;

            EditorGUILayout.EndVertical();

            if (EditorGUI.EndChangeCheck())
            {
                inputNode._uiCache._inputNodeSerializedObject.ApplyModifiedProperties();

                // When cooking, this will force input data to be uploaded
                inputNode.RequiresUpload = true;
            }
        }
		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 textureProperty = layerProperty.FindPropertyRelative("_splatTexture");
									if (textureProperty != null)
									{
										Object textureObject = textureProperty.objectReferenceValue;


										EditorGUILayout.PropertyField(textureProperty, new GUIContent("Texture", "Texture to use for heightfield layer mask."));
										if (textureObject != textureProperty.objectReferenceValue)
										{
											bChanged = true;
										}

										HEU_EditorUI.DrawSeparator();
									}

									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)
										{
											bChanged = true;
										}

										HEU_EditorUI.DrawSeparator();
									}

									if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_metallic", "Metallic", "The metallic value of the splat layer."))
									{
										bChanged = true;
									}

									if (HEU_EditorUtility.EditorDrawFloatSliderProperty(layerProperty, "_smoothness", "Smoothness", "The smoothness value of the splat layer when the main texture has no alpha channel."))
									{
										bChanged = true;
									}

									if (HEU_EditorUtility.EditorDrawVector2RelativeProperty(layerProperty, "_tileSize", "Tile Size (W, H)", "Size of the tile used in the texture of the SplatPrototype."))
									{
										bChanged = true;
									}

									if (HEU_EditorUtility.EditorDrawVector2RelativeProperty(layerProperty, "_tileOffset", "Tile Offset (X, Y)", "Offset of the tile texture of the SplatPrototype."))
									{
										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();
		}
Exemplo n.º 10
0
	private bool DrawDetailsGeneral()
	{
	    bool bChanged = false;
	    {
		string oldPath = HEU_PluginSettings.AssetCachePath;
		EditorGUILayout.LabelField(new GUIContent("Houdini Asset Cache Path:", "Files generated by this plugin will be stored in this folder path relative to Assets/."));
		string newPath = EditorGUILayout.TextField("", oldPath);
		if (!newPath.Equals(oldPath))
		{
		    HEU_PluginSettings.AssetCachePath = newPath;
		    bChanged = true;
		}
	    }
	    HEU_EditorUI.DrawSeparator();
#if UNITY_EDITOR_WIN
	    // Only enabling this for Windows since Mac/Linux have issues dynamically loading
	    // HAPI libraries.
	    {
		string oldPath = HEU_PluginSettings.HoudiniInstallPath;
		string fileExt = "";

		EditorGUILayout.LabelField(new GUIContent("Override Houdini Install Path:",
			"Set a specific Houdini installation to use for this plugin. The plugin's default version of Houdini will be ignored."));
		using (new EditorGUILayout.HorizontalScope())
		{
		    string newPath = EditorGUILayout.DelayedTextField(oldPath);

		    GUIStyle buttonStyle = HEU_EditorUI.GetNewButtonStyle_MarginPadding(0, 0);
		    if (GUILayout.Button("...", buttonStyle, GUILayout.Width(30), GUILayout.Height(18)))
		    {
			string panelMsg = "Select Houdini Install Path";
			panelMsg += " (.app)";

			string openFilePath = UnityEditor.EditorUtility.OpenFolderPanel(panelMsg, newPath, fileExt);
			if (!string.IsNullOrEmpty(openFilePath))
			{
			    newPath = openFilePath;
			}
		    }

		    if (!newPath.Equals(oldPath))
		    {
			string msgPath = !string.IsNullOrEmpty(newPath) ? newPath : HEU_Platform.GetHoudiniEngineDefaultPath();

			string confirmMsg = string.Format(
				"Change the Houdini install path?\n"
				+ "  New path: {0}\n\n"
				+ "You will need to restart Unity to use this path!", msgPath);

			bool result = HEU_EditorUtility.DisplayDialog("Houdini Install Path Changed", confirmMsg, "Confirm", "Cancel");
			if (result)
			{
			    HEU_PluginSettings.HoudiniInstallPath = newPath;
			    bChanged = true;
			}
		    }
		}
#if UNITY_EDITOR_OSX
				GUIStyle labelStyle = new GUIStyle(GUI.skin.label);
				labelStyle.wordWrap = true;
				EditorGUILayout.LabelField("  On macOS, you'll need to select the path to the .app folder.\n  E.g. /Applications/Houdini/Houdini16.5.616/Houdini Core 16.5.616.app", labelStyle);
#endif
	    }
	    HEU_EditorUI.DrawSeparator();
#endif
	    {
		string oldPath = HEU_PluginSettings.HoudiniDebugLaunchPath;
		string fileExt = "";

		EditorGUILayout.LabelField(new GUIContent("Houdini Debug Executable:", "Set Houdini executable to launch when opening debug scenes."));
		using (new EditorGUILayout.HorizontalScope())
		{
		    string newPath = EditorGUILayout.DelayedTextField(oldPath);

		    GUIStyle buttonStyle = HEU_EditorUI.GetNewButtonStyle_MarginPadding(0, 0);
		    if (GUILayout.Button("...", buttonStyle, GUILayout.Width(30), GUILayout.Height(18)))
		    {
			string panelMsg = "Select Houdini Executable";
#if UNITY_EDITOR_OSX
						panelMsg += " (.app)";
#endif

			string openFilePath = UnityEditor.EditorUtility.OpenFilePanel(panelMsg, newPath, fileExt);
			if (!string.IsNullOrEmpty(openFilePath))
			{
			    newPath = openFilePath;
			}
		    }

		    if (!newPath.Equals(oldPath))
		    {
			HEU_PluginSettings.HoudiniDebugLaunchPath = newPath;
			bChanged = true;
		    }
		}
#if UNITY_EDITOR_OSX
		GUIStyle labelStyle = new GUIStyle(GUI.skin.label);
		labelStyle.wordWrap = true;
		EditorGUILayout.LabelField("  On macOS, you'll need to select the path to the .app folder.\n  E.g. /Applications/Houdini/Houdini18.0.100/Houdini Core 18.0.100.app", labelStyle);
#endif
	    }
	    HEU_EditorUI.DrawSeparator();
	    {
		bool oldValue = HEU_PluginSettings.UseFullPathNamesForOutput;
		bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Use Full Path Names For Output");
		if (!newValue.Equals(oldValue))
		{
		    HEU_PluginSettings.UseFullPathNamesForOutput = newValue;
		    bChanged = true;
		}
	    }
	    HEU_EditorUI.DrawSeparator();
	    {
		bool oldValue = HEU_PluginSettings.SetCurrentThreadToInvariantCulture;
		bool newValue = HEU_EditorUI.DrawToggleLeft(oldValue, "Set Current Thread To Invariant Culture", "Enabling this sets to use InvariantCutulre which fixes locale-specific parsing issues such as using comma instead of dot for decimals.");
		if (!newValue.Equals(oldValue))
		{
		    HEU_PluginSettings.SetCurrentThreadToInvariantCulture = newValue;
		    bChanged = true;
		}
	    }

	    return bChanged;
	}
Exemplo n.º 11
0
	public void OnGUI()
	{
	    bool guiEnabled = GUI.enabled;

	    _scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition);

	    using (var vs = new EditorGUILayout.VerticalScope(GUI.skin.box))
	    {
		DrawSection(this, "GENERAL", this.DrawDetailsGeneral, ref _showGeneral);
		DrawSection(this, "ENVIRONMENT", this.DrawDetailsEnvironment, ref _showEnvironment);
		DrawSection(this, "COOKING", this.DrawDetailsCooking, ref _showCooking);
		DrawSection(this, "GEOMETRY", this.DrawDetailsGeometry, ref _showGeometry);
		DrawSection(this, "MATERIALS", this.DrawDetailsMaterials, ref _showMaterials);
		DrawSection(this, "SESSION", this.DrawSessionSettings, ref _showSession);
		DrawSection(this, "TOOLS", this.DrawToolSettings, ref _showTools);
		DrawSection(this, "ADVANCED", this.DrawAdvancedSettings, ref _showAdvanced);

		float buttonHeight = 25;
		float buttonWidth = 200;

		GUIStyle yellowButtonStyle = new GUIStyle(GUI.skin.button);
		yellowButtonStyle.normal.textColor = HEU_EditorUI.GetUISafeTextColorYellow();
		yellowButtonStyle.fontStyle = FontStyle.Bold;
		yellowButtonStyle.fontSize = 12;
		yellowButtonStyle.fixedHeight = buttonHeight;
		yellowButtonStyle.fixedWidth = buttonWidth;

		using (var hs = new EditorGUILayout.HorizontalScope())
		{
		    GUILayout.FlexibleSpace();
		    if (GUILayout.Button(HEU_EditorStrings.RELOAD_SETTINGS, yellowButtonStyle))
		    {
			if (HEU_EditorUtility.DisplayDialog(HEU_EditorStrings.REVERT_SETTINGS + "?",
				"Are you sure you want to reload plugin settings from heu_settings.ini file?",
				"Yes", "No"))
			{
			    HEU_PluginStorage.LoadFromSavedFile();
			    ResetStateAndRepaint();
			}
		    }

		    GUILayout.Space(10);

		    if (GUILayout.Button(HEU_EditorStrings.REVERT_SETTINGS, yellowButtonStyle))
		    {
			if (HEU_EditorUtility.DisplayDialog(HEU_EditorStrings.REVERT_SETTINGS + "?",
				"Are you sure you want to revert all " + HEU_Defines.HEU_PRODUCT_NAME + " plugin settings?",
				"Yes", "No"))
			{
			    HEU_PluginStorage.ClearPluginData();
			    ResetStateAndRepaint();
			}
		    }
		    GUILayout.FlexibleSpace();
		}
	    }

	    EditorGUILayout.EndScrollView();

	    GUI.enabled = guiEnabled;
	}
		private void DrawPaintModeScene()
		{
			if(_selectedAttributesStore == null || _selectedAttributeData == null)
			{
				// Nothing to do if no attribute selected
				return;
			}

			if(!_selectedAttributesStore.HasMeshForPainting())
			{
				// Painting requires a mesh so nothing to do
				return;
			}

			if (!_mouseWithinSceneView)
			{
				return;
			}

			float brushRadius = GetBrushRadius();

			// TODO: use Handles.DrawingScope
			Color originalHandleColor = Handles.color;
			Color newHandleColor = originalHandleColor;
			
			SerializedProperty handleColorProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_brushHandleColor");
			if(handleColorProperty != null)
			{
				newHandleColor = handleColorProperty.colorValue;
			}

			HEU_ToolsInfo.PaintMergeMode paintMergeMode = HEU_ToolsInfo.PaintMergeMode.REPLACE;
			SerializedProperty paintMergeProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_paintMergeMode");
			if (paintMergeProperty != null)
			{
				paintMergeMode = (HEU_ToolsInfo.PaintMergeMode)paintMergeProperty.intValue;
			}

			SerializedProperty isPaintingProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_isPainting");

			// Enable the mesh collider so that we can raycast to paint using brush
			MeshCollider collider = _selectedAttributesStore.GetPaintMeshCollider();
			if (collider != null)
			{
				Ray ray = _currentCamera.ScreenPointToRay(_mousePosition);
				ray.origin = _currentCamera.transform.position;

				RaycastHit hit;
				if (collider.Raycast(ray, out hit, _intersectionRayLength))
				{
					if (_currentEvent.type == EventType.ScrollWheel && _currentEvent.shift)
					{
						// Brush resize
						brushRadius -= _currentEvent.delta.y * _mouseWheelBrushSizeMultiplier;
						brushRadius = UpdateBrushSize(brushRadius);

						_GUIChanged = true;
						_currentEvent.Use();
					}
					else if (_currentEvent.type == EventType.MouseDrag && _currentEvent.shift)
					{
						// Brush resize
						brushRadius += _currentEvent.delta.x * _mouseWheelBrushSizeMultiplier;
						brushRadius = UpdateBrushSize(brushRadius);

						_GUIChanged = true;
						_currentEvent.Use();
					}
					else if (_currentEvent.button == 0 && !_currentEvent.shift && !_currentEvent.alt && !_currentEvent.control && !_mouseOverInfoPanel)
					{
						// Painting

						if (_currentEvent.type == EventType.MouseDown && !isPaintingProperty.boolValue)
						{
							PaintingStarted(isPaintingProperty);
						}

						if (isPaintingProperty.boolValue)
						{
							if(_currentEvent.type == EventType.MouseDown || _currentEvent.type == EventType.MouseDrag)
							{
								HandlePaintEvent(hit, brushRadius, paintMergeMode);

								_currentEvent.Use();
							}
						}
					}

					if (!_mouseOverInfoPanel)
					{
						Handles.color = newHandleColor;
						Vector3 endPt = hit.point + (Vector3.Normalize(hit.normal) * brushRadius);
						Handles.DrawAAPolyLine(2f, new Vector3[] { hit.point, endPt });

						HEU_EditorUI.DrawCircleCap(_controlID, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal), brushRadius);
					}
				}
			}

			switch (_currentEvent.type)
			{
				case EventType.MouseDown:
				{
					// Don't use event here as it will ignore mouse camera controls
					break;
				}
				case EventType.MouseUp:
				{
					if (_currentEvent.button == 0)
					{
						if(!_currentEvent.shift && !_currentEvent.alt && !_currentEvent.control)
						{
							if (isPaintingProperty != null && isPaintingProperty.boolValue)
							{
								_currentEvent.Use();
							}

							PaintingFinished(isPaintingProperty);
						}
					}
					break;
				}
				case EventType.MouseMove:
				{
					// Use the mouse move event will force a repaint allowing for much more responsive UI
					_currentEvent.Use();
					break;
				}
				case EventType.Layout:
				{
					// This disables deselection on asset while in Edit mode
					HandleUtility.AddDefaultControl(_controlID);

					break;
				}
				case EventType.Repaint:
				{
					
					break;
				}
			}

			Handles.color = originalHandleColor;
		}
		private void DrawPaintAttributeValues()
		{
			// Display the values as editable fields

			if (_selectedAttributeData == null)
			{
				return;
			}

			if(!_selectedAttributesStore.HasMeshForPainting())
			{
				HEU_EditorUI.DrawWarningLabel(_noMeshForPainting);
				return;
			}

			SerializedProperty selectedToolsValuesProperty = null;

			if (_selectedAttributeData._attributeType == HEU_AttributeData.AttributeType.INT)
			{
				selectedToolsValuesProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_paintIntValue");
				if (selectedToolsValuesProperty != null)
				{
					ResizeSerializedPropertyArray(selectedToolsValuesProperty, _selectedAttributeData._attributeInfo.tupleSize);
					HEU_EditorUtility.EditorDrawArrayProperty(selectedToolsValuesProperty, HEU_EditorUtility.EditorDrawIntProperty, _paintValuesLabel);
				}
			}
			else if (_selectedAttributeData._attributeType == HEU_AttributeData.AttributeType.FLOAT)
			{
				selectedToolsValuesProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_paintFloatValue");
				if (selectedToolsValuesProperty != null)
				{
					ResizeSerializedPropertyArray(selectedToolsValuesProperty, _selectedAttributeData._attributeInfo.tupleSize);
					HEU_EditorUtility.EditorDrawArrayProperty(selectedToolsValuesProperty, HEU_EditorUtility.EditorDrawFloatProperty, _paintValuesLabel);
				}

				// Display paint color selector if this is a color attribute
				if (_selectedAttributeData.IsColorAttribute())
				{
					Color color = Color.white;

					if (selectedToolsValuesProperty.arraySize >= 3)
					{
						color.r = selectedToolsValuesProperty.GetArrayElementAtIndex(0).floatValue;
						color.g = selectedToolsValuesProperty.GetArrayElementAtIndex(1).floatValue;
						color.b = selectedToolsValuesProperty.GetArrayElementAtIndex(2).floatValue;

						if (selectedToolsValuesProperty.arraySize >= 4)
						{
							color.a = selectedToolsValuesProperty.GetArrayElementAtIndex(3).floatValue;
						}
					}

					Color newColor = EditorGUILayout.ColorField(_paintColorLabel, color);
					if (color != newColor)
					{
						if (selectedToolsValuesProperty.arraySize >= 3)
						{
							selectedToolsValuesProperty.GetArrayElementAtIndex(0).floatValue = newColor.r;
							selectedToolsValuesProperty.GetArrayElementAtIndex(1).floatValue = newColor.g;
							selectedToolsValuesProperty.GetArrayElementAtIndex(2).floatValue = newColor.b;

							if (selectedToolsValuesProperty.arraySize >= 4)
							{
								selectedToolsValuesProperty.GetArrayElementAtIndex(3).floatValue = newColor.a;
							}
						}
					}
				}

			}
			else if (_selectedAttributeData._attributeType == HEU_AttributeData.AttributeType.STRING)
			{
				selectedToolsValuesProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_paintStringValue");
				if (selectedToolsValuesProperty != null)
				{
					ResizeSerializedPropertyArray(selectedToolsValuesProperty, _selectedAttributeData._attributeInfo.tupleSize);
					HEU_EditorUtility.EditorDrawArrayProperty(selectedToolsValuesProperty, HEU_EditorUtility.EditorDrawTextProperty, _paintValuesLabel);
				}
			}

			if (!_selectedAttributeData.IsColorAttribute())
			{
				HEU_EditorUtility.EditorDrawSerializedProperty(_toolsInfoSerializedObject, "_affectedAreaPaintColor", _affectedAreaColorLabel, "Color to show painted area.");
			}
		}
		private void DrawAttributeSelection()
		{
			// Try to re-use the last selected node
			string lastSelectedNodeName = null;
			SerializedProperty lastSelectedNodeNameProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_lastAttributeNodeName");
			if (lastSelectedNodeNameProperty != null)
			{
				lastSelectedNodeName = lastSelectedNodeNameProperty.stringValue;
			}

			HEU_AttributesStore foundAttributeStore = null;

			// Get the names of the all editable nodes having an attribute store for this asset
			// While doing that, we'll find the last selected attribute store
			int lastSelectedIndex = 0;
			List<string> nodeNames = new List<string>();
			foreach (HEU_AttributesStore attributeStore in _attributesStores)
			{
				string geoName = attributeStore.GeoName;
				if (!nodeNames.Contains(geoName))
				{
					nodeNames.Add(geoName);

					// Either re-select last selected node, or select the first one found
					if (string.IsNullOrEmpty(lastSelectedNodeName) || lastSelectedNodeName.Equals(geoName))
					{
						lastSelectedNodeName = geoName;
						lastSelectedIndex = nodeNames.Count - 1;
						foundAttributeStore = attributeStore;
					}
				}
			}

			// Try to re-use the last selected attribute
			string lastSelectedAttributeName = null;
			SerializedProperty lastSelectedAttributeProperty = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_lastAttributeName");
			if (lastSelectedAttributeProperty != null)
			{
				lastSelectedAttributeName = lastSelectedAttributeProperty.stringValue;
			}

			// Display a dropdown list of editable nodes with attribute stores
			int currentSelectedIndex = EditorGUILayout.Popup(_editableNodeLabel, lastSelectedIndex, nodeNames.ToArray());
			if (currentSelectedIndex != lastSelectedIndex)
			{
				// User changed node selection, so update it
				lastSelectedNodeName = nodeNames[currentSelectedIndex];

				foundAttributeStore = null;

				foreach (HEU_AttributesStore attributeStore in _attributesStores)
				{
					string geoName = attributeStore.GeoName;
					if (geoName.Equals(lastSelectedNodeName))
					{
						foundAttributeStore = attributeStore;
						break;
					}
				}

				SetSelectedAttributeStore(foundAttributeStore);

				// Reset selected attribute to first attribute
				SetSelectedAttributeData(_selectedAttributesStore.GetAttributeData(0));
				lastSelectedAttributeName = _selectedAttributeData._name;
				lastSelectedAttributeProperty.stringValue = lastSelectedAttributeName;

				lastSelectedNodeNameProperty.stringValue = lastSelectedNodeName;

				_GUIChanged = true;
			}
			else
			{
				// Since selected node hasn't changed, re-use the last selected attribute

				SetSelectedAttributeStore(foundAttributeStore);

				SetSelectedAttributeData(_selectedAttributesStore.GetAttributeData(lastSelectedAttributeName));
			}

			// Get attribute names for selected node
			List<string> attributeNames = _selectedAttributesStore.GetAttributeNames();

			// Find the last selected attribute index
			int lastAttributeIndex = -1;
			if (!string.IsNullOrEmpty(lastSelectedAttributeName))
			{
				for(int i = 0; i < attributeNames.Count; ++i)
				{
					if (lastSelectedAttributeName.Equals(attributeNames[i]))
					{
						lastAttributeIndex = i;
						break;
					}
				}
			}

			// Use first attribute as default if none selected last time
			if(lastAttributeIndex == -1)
			{
				lastAttributeIndex = 0;
				HEU_AttributeData data = _selectedAttributesStore.GetAttributeData(0);
				if (data != null)
				{
					lastSelectedAttributeProperty.stringValue = data._name;
				}
			}

			// Display attributes as dropdown
			if (attributeNames.Count > 0)
			{
				int currentAttributeIndex = EditorGUILayout.Popup(_attributeLabel, lastAttributeIndex, attributeNames.ToArray());
				if (currentAttributeIndex != lastAttributeIndex)
				{
					// User changed attribute selection, so update it
					SetSelectedAttributeData(_selectedAttributesStore.GetAttributeData(attributeNames[currentAttributeIndex]));
					lastSelectedAttributeProperty.stringValue = _selectedAttributeData._name;
				}
			}
		}
Exemplo n.º 15
0
	public static void CookAll()
	{
	    HEU_EditorUtility.CookAll();
	}
Exemplo n.º 16
0
	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);
		    }
		}
	    }
	}
Exemplo n.º 17
0
	public static void RebuildSelected()
	{
	    HEU_EditorUtility.RebuildSelected();
	}
Exemplo n.º 18
0
	public static void ExecuteToolOperatorSingle(string toolName, string toolPath, GameObject[] inputObjects)
	{
	    // Single operator means single asset input. If multiple inputs are provided, create tool for each input.

	    List<GameObject> outputObjectsToSelect = new List<GameObject>();

	    int numInputs = inputObjects.Length;
	    for (int i = 0; i < numInputs; ++i)
	    {
		if (!IsValidInput(inputObjects[i]))
		{
		    continue;
		}
		GameObject inputObject = inputObjects[i];

		GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
		if (go != null)
		{
		    HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
		    if (assetRoot != null)
		    {
			HEU_HoudiniAsset asset = assetRoot._houdiniAsset;
			HEU_SessionBase session = asset.GetAssetSession(true);

			List<HEU_InputNode> inputNodes = asset.GetInputNodes();
			if (inputNodes == null || inputNodes.Count == 0)
			{
			    Debug.LogErrorFormat("Unable to assign input geometry due to no asset inputs on selected tool.");
			}
			else
			{
			    HEU_InputNode inputNode = inputNodes[0];

			    inputNode.ResetInputNode(session);

			    inputNode.ChangeInputType(session, HEU_InputNode.InputObjectType.UNITY_MESH);

			    HEU_InputObjectInfo inputInfo = inputNode.AddInputEntryAtEnd(inputObject);
			    inputInfo._useTransformOffset = false;
			    inputNode.KeepWorldTransform = true;
			    inputNode.PackGeometryBeforeMerging = false;

			    inputNode.RequiresUpload = true;

			    asset.RequestCook(true, true, true, true);

			    outputObjectsToSelect.Add(assetRoot.gameObject);
			}
		    }
		}
		else
		{
		    Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
		}
	    }

	    if (outputObjectsToSelect.Count > 0)
	    {
		HEU_EditorUtility.SelectObjects(outputObjectsToSelect.ToArray());
	    }
	}
Exemplo n.º 19
0
	public static void BakeAndReplaceSelected()
	{
	    HEU_EditorUtility.BakeAndReplaceSelectedInScene();
	}
Exemplo n.º 20
0
	public static void ExecuteToolOperatorMultiple(string toolName, string toolPath, GameObject[] inputObjects)
	{
	    GameObject outputObjectToSelect = null;

	    GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), false);
	    if (go == null)
	    {
		Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
		return;
	    }

	    HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
	    if (assetRoot != null)
	    {
		HEU_HoudiniAsset asset = assetRoot._houdiniAsset;
		HEU_SessionBase session = asset.GetAssetSession(true);

		int numInputs = inputObjects.Length;

		List<HEU_InputNode> inputNodes = asset.GetInputNodes();
		if (inputNodes == null || inputNodes.Count == 0)
		{
		    Debug.LogErrorFormat("Unable to assign input geometry due to no asset inputs on selected tool.");
		}
		else
		{
		    // User could have selected any number of inputs objects, and asset could have any number of inputs.
		    // So use minimum of either to set input object into asset input.
		    int minInputCount = Mathf.Min(inputNodes.Count, numInputs);
		    for (int i = 0; i < minInputCount; ++i)
		    {
			if (!IsValidInput(inputObjects[i]))
			{
			    continue;
			}
			GameObject inputObject = inputObjects[i];

			HEU_InputNode inputNode = inputNodes[i];
			inputNode.ResetInputNode(session);

			inputNode.ChangeInputType(session, HEU_InputNode.InputObjectType.UNITY_MESH);

			HEU_InputObjectInfo inputInfo = inputNode.AddInputEntryAtEnd(inputObject);
			inputInfo._useTransformOffset = false;
			inputNode.KeepWorldTransform = true;
			inputNode.PackGeometryBeforeMerging = false;

			inputNode.RequiresUpload = true;
		    }

		    asset.RequestCook(true, true, true, true);

		    outputObjectToSelect = assetRoot.gameObject;
		}
	    }

	    if (outputObjectToSelect != null)
	    {
		HEU_EditorUtility.SelectObject(outputObjectToSelect);
	    }
	}
Exemplo n.º 21
0
	public static void ExportSelecedAssetsGeo()
	{
	    HEU_EditorUtility.ExportSelectedAssetsToGeoFiles();
	}
Exemplo n.º 22
0
        /// <summary>
        /// Open given session in a new Houdini instance.
        /// </summary>
        /// <param name="session">Session to open. If null, will use default session.</param>
        /// <returns>True if successfully loaded session</returns>
        public static bool OpenSessionInHoudini(HEU_SessionBase session = null)
        {
            if (session == null || !session.IsSessionValid())
            {
                session = GetOrCreateDefaultSession();
                if (session == null || !session.IsSessionValid())
                {
                    session.SetSessionErrorMsg("No valid session found. Unable to open session in Houdini!", true);
                    return false;
                }
            }

            string HIPName = string.Format("hscene_{0}.hip", System.IO.Path.GetRandomFileName().Replace(".", ""));
            string HIPPath = Application.temporaryCachePath + HEU_Platform.DirectorySeparatorStr + HIPName;

            if (!session.SaveHIPFile(HIPPath, false))
            {
                session.SetSessionErrorMsg("Unable to save session to .hip file at: " + HIPPath, true);
                return false;
            }
            Debug.Log("Saved session to " + HIPPath);

            string HoudiniPath = HEU_PluginSettings.HoudiniDebugLaunchPath;

#if UNITY_EDITOR_OSX
			// On macOS, need to find the actual executable, which is within one of .app folders
			// that Houdini ships with, depending on the installation type.
			// HoudiniPath should by default be pointing to the HFS (Houdini install) folder.
			// Or user should have selected one of the .app folders within.
			
			// If not set to .app, then set it based on what app is available
			if (!HoudiniPath.EndsWith(".app", System.StringComparison.InvariantCulture))
			{
				string[] appNames = { "FX", "Core", "Indie", "Apprentice", "Indie", "Indie Steam Edition" };
				string tryPath;
				foreach(string name in appNames)
				{
					tryPath = HEU_Platform.BuildPath(HoudiniPath, string.Format("Houdini {0} {1}.app", 
						name,
						HEU_HoudiniVersion.HOUDINI_VERSION_STRING));
					if (HEU_Platform.DoesPathExist(tryPath))
					{
						HoudiniPath = tryPath;
						break;
					}
				}
			}

			if (HoudiniPath.EndsWith(".app", System.StringComparison.InvariantCulture))
			{
				// Get the executable name inside the .app, but the executable
				// name is based on the license type, so need to query the 
				// license type and map it to executable name:
				// 	Houdini Apprenctice 18.0.100
				// 	Houdini Core 18.0.100
				// 	Houdini FX 18.0.100
				// 	Houdini Indie 18.0.100
				// 	Houdini Indie Steam Edition 18.0.100
				//HoudiniPath = "/Applications/Houdini/Houdini18.0.100/Houdini Indie 18.0.100.app";
				string hexecutable = "";
				string pattern = @"(.*)/Houdini (.*) (.*).app$";
				Regex reg = new Regex(pattern); 
				Match match = reg.Match(HoudiniPath);
				if (match.Success && match.Groups.Count > 2)
				{
					switch(match.Groups[2].Value)
					{
						case "Apprentice": hexecutable = "happrentice"; break;
						case "Core": hexecutable = "houdinicore"; break;
						case "FX": hexecutable = "houdini"; break;
						case "Indie": hexecutable = "hindie"; break;
						case "Indie Steam Edition": hexecutable = "hindie.steam"; break;
						default: break;
					}
				}

				HoudiniPath += "/Contents/MacOS/" + hexecutable;
			}
#endif

            var HoudiniProcess = new System.Diagnostics.Process();
            HoudiniProcess.StartInfo.FileName = HoudiniPath;
            HoudiniProcess.StartInfo.Arguments = string.Format("\"{0}\"", HIPPath);
            if (!HoudiniProcess.Start())
            {
                session.SetSessionErrorMsg("Unable to start Houdini. Check that the Houdini Debug Exectable path is valid in Plugin Settings.", true);
                HEU_EditorUtility.RevealInFinder(HIPPath);
                return false;
            }

            return true;
        }
Exemplo n.º 23
0
	public static void QueryMeshTopology()
	{
	    HEU_EditorUtility.QuerySelectedMeshTopology();
	}
Exemplo n.º 24
0
	public static void GetSessionInfo()
	{
	    HEU_EditorUtility.DisplayDialog("Houdini Engine", HEU_SessionManager.GetSessionInfo(), "OK");
	}
Exemplo n.º 25
0
		/// <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())
					{
						bool bCheckParametersChanged = false;
						bool bAsync = true;
						bool bForceCook = false;
						bool bUploadParameters = true;
						asset.RequestCook(bCheckParametersChanged, bAsync, bForceCook, bUploadParameters);
					}
				}

				HEU_EditorUI.EndSection();
			}
		}
Exemplo n.º 26
0
	public static void ShowInstallationInfo()
	{
	    HEU_EditorUtility.DisplayDialog(HEU_Defines.HEU_INSTALL_INFO, HEU_HAPIUtility.GetHoudiniEngineInstallationInfo(), "OK");
	}
Exemplo n.º 27
0
		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();
		}
Exemplo n.º 28
0
	public static void CookSelected()
	{
	    HEU_EditorUtility.CookSelected();
	}
Exemplo n.º 29
0
	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 float GetBrushRadius()
		{
			SerializedProperty property = HEU_EditorUtility.GetSerializedProperty(_toolsInfoSerializedObject, "_paintBrushSize");
			return (property != null) ? property.floatValue : 1f;
		}