private GameObject GetGameObjectFromType(Object obj, System.Type type)
 {
     if (type == typeof(GameObject))
     {
         return(obj as GameObject);
     }
     else if (type == typeof(HEU_HoudiniAssetRoot))
     {
         HEU_HoudiniAssetRoot heuRoot = obj as HEU_HoudiniAssetRoot;
         return(heuRoot.gameObject);
     }
     else if (type == typeof(Terrain))
     {
         Terrain terrain = obj as Terrain;
         return(terrain.gameObject);
     }
     else if (type == typeof(HEU_BoundingVolume))
     {
         HEU_BoundingVolume volume = obj as HEU_BoundingVolume;
         return(volume.gameObject);
     }
     else if (type == typeof(Tilemap))
     {
         Tilemap tilemap = obj as Tilemap;
         return(tilemap.gameObject);
     }
     else
     {
         HEU_Logger.LogErrorFormat("Unsupported type {0} for Selection Window.", type);
         return(null);
     }
 }
Пример #2
0
	private static void ProcessPendingBuildAction(
	    HEU_HoudiniAsset.AssetBuildAction pendingBuildAction,
	    SerializedProperty pendingBuildProperty,
	    HEU_HoudiniAssetRoot assetRoot, 
	    SerializedObject assetRootSerializedObject, 
	    HEU_HoudiniAsset asset, 
	    SerializedObject assetObject)
	{
	    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;
		    }

		    // But we do want to always upload input geometry on user hitting Recook expliclity
		    SerializedProperty forceUploadInputs = HEU_EditorUtility.GetSerializedProperty(assetObject, "_forceUploadInputs");
		    if (forceUploadInputs != null)
		    {
			forceUploadInputs.boolValue = true;
		    }
		}
	    }
	}
Пример #3
0
	public static void CreatePDGAssetLink()
	{
	    GameObject selectedGO = Selection.activeGameObject;
	    if (selectedGO != null)
	    {
		HEU_HoudiniAssetRoot assetRoot = selectedGO.GetComponent<HEU_HoudiniAssetRoot>();
		if (assetRoot != null)
		{
		    if (assetRoot._houdiniAsset != null)
		    {
			string name = string.Format("{0}_PDGLink", assetRoot._houdiniAsset.AssetName);

			GameObject go = new GameObject(name);
			HEU_PDGAssetLink assetLink = go.AddComponent<HEU_PDGAssetLink>();
			assetLink.Setup(assetRoot._houdiniAsset);

			Selection.activeGameObject = go;
		    }
		    else
		    {
			Debug.LogError("Selected gameobject is not an instantiated HDA. Failed to create PDG Asset Link.");
		    }
		}
		else
		{
		    Debug.LogError("Selected gameobject is not an instantiated HDA. Failed to create PDG Asset Link.");
		}
	    }
	    else
	    {
		//Debug.LogError("Nothing selected. Select an instantiated HDA first.");
		HEU_EditorUtility.DisplayErrorDialog("PDG Asset Link", "No HDA selected. You must select an instantiated HDA first.", "OK");
	    }
	}
		private void DisconnectInputAssetActor(HEU_SessionBase session)
		{
			if (!_inputAssetConnected)
			{
				return;
			}

			if (_inputNodeType == InputNodeType.PARAMETER)
			{
				HEU_ParameterData paramData = _parentAsset.Parameters.GetParameter(_paramName);
				if(paramData == null)
				{
					Debug.LogErrorFormat("Unable to find parameter with name {0}!", _paramName);
				}
				else if (!session.SetParamStringValue(_nodeID, "", paramData.ParmID, 0))
				{
					Debug.LogErrorFormat("Unable to clear object path parameter for input node!");
				}
			}
			else if(session != null && _nodeID != HEU_Defines.HEU_INVALID_NODE_ID)
			{
				session.DisconnectNodeInput(_nodeID, _inputIndex, false);
			}

			HEU_HoudiniAssetRoot inputAssetRoot = _inputAsset != null ? _inputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
			if (inputAssetRoot != null)
			{
				_parentAsset.DisconnectFromUpstream(inputAssetRoot._houdiniAsset);
			}

			// Must clear this and not delete as this points to existing asset node.
			// If _inputObjectType changes to MESH, node with this ID will get deleted. 
			_connectedNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
			_inputAssetConnected = false;
		}
Пример #5
0
		/// <summary>
		/// Update the input connection based on the fact that the owner asset was recreated
		/// in the given session. Asset input connections will be updated, while mesh input
		/// connections will be invalidated without cleaning up because the IDs can't be trusted.
		/// </summary>
		/// <param name="session"></param>
		public void UpdateOnAssetRecreation(HEU_SessionBase session)
		{
			if (_inputObjectType == InputObjectType.HDA && IsInputAssetConnected())
			{
				// For asset inputs, cook the asset if its not valid in session, and update the ID
				HEU_HoudiniAssetRoot inputAssetRoot = _connectedInputAsset.GetComponent<HEU_HoudiniAssetRoot>();
				if (inputAssetRoot != null && !inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
				{
					inputAssetRoot._houdiniAsset.RequestCook(true, false, true, true);

					// Update the _connectNodeID to the connected asset's ID since it might have changed during cook
					if (_connectedNodeID != HEU_Defines.HEU_INVALID_NODE_ID)
					{
						HAPI_NodeId otherAssetID = inputAssetRoot._houdiniAsset != null ? inputAssetRoot._houdiniAsset.AssetID : HEU_Defines.HEU_INVALID_NODE_ID;
						if (otherAssetID != _connectedNodeID)
						{
							_connectedNodeID = otherAssetID;
						}

						if(_connectedNodeID == HEU_Defines.HEU_INVALID_NODE_ID)
						{
							ClearConnectedInputAsset();
						}
					}
				}
			}
			else if(_inputObjectType == InputObjectType.UNITY_MESH)
			{
				// For mesh input, invalidate _inputObjectsConnectedAssetIDs and _connectedNodeID as their
				// nodes most likely don't exist, and the IDs will not be correct since this asset got recreated
				// Note that _inputObjects don't need to be cleared as they will be used when recreating the connections.
				_inputObjectsConnectedAssetIDs.Clear();
				_connectedNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
			}
		}
Пример #6
0
        public static GameObject CreateNewAsset(HEU_HoudiniAsset.HEU_AssetType assetType, string rootName = "HoudiniAsset", Transform parentTransform = null, HEU_SessionBase session = null, bool bBuildAsync = true)
        {
            if (session == null)
            {
                session = HEU_SessionManager.GetOrCreateDefaultSession();
            }
            if (!session.IsSessionValid())
            {
                Debug.LogWarning("Invalid Houdini Engine session!");
                return(null);
            }

            // This will be the root GameObject for the HDA. Adding HEU_HoudiniAssetRoot
            // allows to use a custom Inspector.
            GameObject           rootGO    = new GameObject();
            HEU_HoudiniAssetRoot assetRoot = rootGO.AddComponent <HEU_HoudiniAssetRoot>();

            // Set the game object's name to the asset's name
            rootGO.name = string.Format("{0}{1}", rootName, rootGO.GetInstanceID());

            // Under the root, we'll add the HEU_HoudiniAsset onto another GameObject
            // This will be marked as EditorOnly to strip out for builds
            GameObject hdaGEO = new GameObject(HEU_PluginSettings.HDAData_Name);

            hdaGEO.transform.parent = rootGO.transform;

            // This holds all Houdini Engine data
            HEU_HoudiniAsset asset = hdaGEO.AddComponent <HEU_HoudiniAsset>();

            // Marking as EditorOnly to be excluded from builds
            if (HEU_GeneralUtility.DoesUnityTagExist(HEU_PluginSettings.EditorOnly_Tag))
            {
                hdaGEO.tag = HEU_PluginSettings.EditorOnly_Tag;
            }

            // Bind the root to the asset
            assetRoot._houdiniAsset = asset;

            // Populate asset with what we know
            asset.SetupAsset(assetType, null, rootGO, session);

            // Build it in Houdini Engine
            asset.RequestReload(bBuildAsync);

            if (parentTransform != null)
            {
                rootGO.transform.parent        = parentTransform;
                rootGO.transform.localPosition = Vector3.zero;
            }
            else
            {
                rootGO.transform.position = Vector3.zero;
            }

            return(rootGO);
        }
Пример #7
0
	internal static bool CreateInputNodeWithMultiAssets(HEU_SessionBase session, HEU_HoudiniAsset parentAsset,
		ref HAPI_NodeId connectMergeID, ref List<HEU_InputHDAInfo> inputAssetInfos,
		 bool bKeepWorldTransform, HAPI_NodeId mergeParentID = -1)
	{
	    // Create the merge SOP node that the input nodes are going to connect to.
	    if (!session.CreateNode(mergeParentID, "SOP/merge", null, true, out connectMergeID))
	    {
		HEU_Logger.LogErrorFormat("Unable to create merge SOP node for connecting input assets.");
		return false;
	    }

	    int numInputs = inputAssetInfos.Count;
	    for (int i = 0; i < numInputs; ++i)
	    {
		inputAssetInfos[i]._connectedInputNodeID = HEU_Defines.HEU_INVALID_NODE_ID;

		if (inputAssetInfos[i]._pendingGO == null)
		{
		    continue;
		}

		// ID of the asset that will be connected
		HAPI_NodeId inputAssetID = HEU_Defines.HEU_INVALID_NODE_ID;

		HEU_HoudiniAssetRoot inputAssetRoot = inputAssetInfos[i]._pendingGO.GetComponent<HEU_HoudiniAssetRoot>();
		if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
		{
		    if (!inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
		    {
			// Force a recook if its not valid (in case it hasn't been loaded into the session)
			inputAssetRoot._houdiniAsset.RequestCook(true, false, true, true);
		    }

		    inputAssetID = inputAssetRoot._houdiniAsset.AssetID;
		}

		if (inputAssetID == HEU_Defines.HEU_INVALID_NODE_ID)
		{
		    continue;
		}

		if (!session.ConnectNodeInput(connectMergeID, i, inputAssetID))
		{
		    HEU_Logger.LogErrorFormat("Unable to connect input nodes!");
		    return false;
		}

		inputAssetInfos[i]._connectedInputNodeID = inputAssetID;
		inputAssetInfos[i]._connectedGO = inputAssetInfos[i]._pendingGO;
		inputAssetInfos[i]._connectedMergeNodeID = connectMergeID;

		parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);
	    }

	    return true;
	}
Пример #8
0
		public void ReconnectToUpstreamAsset()
		{
			if (_inputObjectType == InputObjectType.HDA && IsInputAssetConnected())
			{
				HEU_HoudiniAssetRoot inputAssetRoot = _connectedInputAsset != null ? _connectedInputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
				if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
				{
					_parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);
				}
			}
		}
Пример #9
0
		/// <summary>
		/// Force cook upstream connected asset if its not valid in given session.
		/// </summary>
		/// <param name="session"></param>
		public void CookUpstreamConnectedAsset(HEU_SessionBase session)
		{
			if(_inputObjectType == InputObjectType.HDA && IsInputAssetConnected())
			{
				HEU_HoudiniAssetRoot inputAssetRoot = _connectedInputAsset.GetComponent<HEU_HoudiniAssetRoot>();
				if (inputAssetRoot != null && !inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
				{
					inputAssetRoot._houdiniAsset.RequestCook(false, false, true, true);
				}
			}
		}
Пример #10
0
		private void ClearConnectedInputAsset()
		{
			if (_connectedInputAsset != null)
			{
				HEU_HoudiniAssetRoot inputAssetRoot = _connectedInputAsset != null ? _connectedInputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
				if (inputAssetRoot != null)
				{
					_parentAsset.DisconnectFromUpstream(inputAssetRoot._houdiniAsset);
				}
				_connectedInputAsset = null;
			}
		}
Пример #11
0
	public void ReconnectToUpstreamAsset()
	{
	    if (_inputObjectType == InputObjectType.HDA && AreAnyInputHDAsConnected())
	    {
		foreach (HEU_InputHDAInfo hdaInfo in _inputAssetInfos)
		{
		    HEU_HoudiniAssetRoot inputAssetRoot = hdaInfo._connectedGO != null ? hdaInfo._connectedGO.GetComponent<HEU_HoudiniAssetRoot>() : null;
		    if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
		    {
			_parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);
		    }
		}
	    }
	}
Пример #12
0
	private bool FindAddToInputHDA(string gameObjectName)
	{
	    HEU_HoudiniAssetRoot inputAssetRoot = HEU_GeneralUtility.GetHDAByGameObjectNameInScene(gameObjectName);
	    if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
	    {
		// Adding to list will take care of reconnecting
		InternalAddInputHDAAtEnd(inputAssetRoot.gameObject);
		return true;
	    }
	    else
	    {
		Debug.LogWarningFormat("HDA with gameobject name {0} not found. Unable to set input asset.", gameObjectName);
	    }

	    return false;
	}
Пример #13
0
        /// <summary>
        /// Get the HDA in the current Unity scene, if it exists, with the assetID.
        /// </summary>
        /// <param name="assetID">Asset with this ID will be searched for</param>
        /// <returns>The asset in the scene with the ID, or null if not found</returns>
        public static HEU_HoudiniAssetRoot GetAssetInScene(HAPI_NodeId assetID)
        {
            HEU_HoudiniAssetRoot foundAsset = null;

            HEU_HoudiniAssetRoot[] houdiniAssets = GameObject.FindObjectsOfType <HEU_HoudiniAssetRoot>();

            foreach (HEU_HoudiniAssetRoot assetRoot in houdiniAssets)
            {
                if (assetRoot._houdiniAsset != null && assetRoot._houdiniAsset.AssetID == assetID)
                {
                    foundAsset = assetRoot;
                    break;
                }
            }

            return(foundAsset);
        }
 private GameObject GetGameObjectFromType(Object obj, System.Type type)
 {
     if (type == typeof(GameObject))
     {
         return(obj as GameObject);
     }
     else if (type == typeof(HEU_HoudiniAssetRoot))
     {
         HEU_HoudiniAssetRoot heuRoot = obj as HEU_HoudiniAssetRoot;
         return(heuRoot.gameObject);
     }
     else
     {
         Debug.LogErrorFormat("Unsupported type {0} for Selection Window.", type);
         return(null);
     }
 }
		private void ConnectInputAssetActor(HEU_SessionBase session)
		{
			if(_inputAssetConnected)
			{
				return;
			}

			HEU_HoudiniAssetRoot inputAssetRoot = _inputAsset != null ? _inputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
			if (inputAssetRoot != null && inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
			{
				_connectedNodeID = inputAssetRoot._houdiniAsset.AssetID;

				ConnectInputNode(session);

				_parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);

				_inputAssetConnected = true;
			}
		}
Пример #16
0
		public static void ExecuteToolOperatorSingle(string toolName, string toolPath, GameObject[] inputObjects)
		{
			GameObject go = HEU_HAPIUtility.InstantiateHDA(toolPath, Vector3.zero, HEU_SessionManager.GetOrCreateDefaultSession(), true);
			if (go != null)
			{
				HEU_HoudiniAssetRoot assetRoot = go.GetComponent<HEU_HoudiniAssetRoot>();
				if (assetRoot != null)
				{
					//assetRoot._houdiniAsset
					// TODO
				}

				HEU_EditorUtility.SelectObject(go);
			}
			else
			{
				Debug.LogWarningFormat("Failed to instantiate tool: {0}", toolName);
			}
		}
        public void TriggerButton(GraphReference reference)
        {
            Flow flow = Flow.New(reference);
            HEU_HoudiniAssetRoot hdaAssetRoot = flow.GetValue <HEU_HoudiniAssetRoot>(inputHDA);

            if (hdaAssetRoot != null && hdaAssetRoot.HoudiniAsset != null)
            {
                hdaAsset = hdaAssetRoot.HoudiniAsset;
            }

            System.Action ContinueFlow = () =>
            {
                flow.Invoke(trigger);
            };

            Debug.Log("Triggered");

            ContinueFlow();
        }
Пример #18
0
        /// <summary>
        /// Load and instantiate an HDA asset in Unity and Houdini, for the asset located at given path.
        /// </summary>
        /// <param name="filePath">Full path to the HDA in Unity project</param>
        /// <param name="initialPosition">Initial location to create the instance in Unity.</param>
        /// <returns>Returns the newly created gameobject for the asset in the scene, or null if creation failed.</returns>
        public static GameObject InstantiateHDA(string filePath, Vector3 initialPosition, HEU_SessionBase session, bool bBuildAsync)
        {
            if (filePath == null || !HEU_Platform.DoesFileExist(filePath))
            {
                return(null);
            }

            // This will be the root GameObject for the HDA. Adding HEU_HoudiniAssetRoot
            // allows to use a custom Inspector.
            GameObject           rootGO    = new GameObject(HEU_Defines.HEU_DEFAULT_ASSET_NAME);
            HEU_HoudiniAssetRoot assetRoot = rootGO.AddComponent <HEU_HoudiniAssetRoot>();

            // Under the root, we'll add the HEU_HoudiniAsset onto another GameObject
            // This will be marked as EditorOnly to strip out for builds
            GameObject hdaGEO = new GameObject(HEU_PluginSettings.HDAData_Name);

            hdaGEO.transform.parent = rootGO.transform;

            // This holds all Houdini Engine data
            HEU_HoudiniAsset asset = hdaGEO.AddComponent <HEU_HoudiniAsset>();

            // Marking as EditorOnly to be excluded from builds
            if (HEU_GeneralUtility.DoesUnityTagExist(HEU_PluginSettings.EditorOnly_Tag))
            {
                hdaGEO.tag = HEU_PluginSettings.EditorOnly_Tag;
            }

            // Bind the root to the asset
            assetRoot._houdiniAsset = asset;

            // Populate asset with what we know
            asset.SetupAsset(HEU_HoudiniAsset.HEU_AssetType.TYPE_HDA, filePath, rootGO, session);

            // Build it in Houdini Engine
            asset.RequestReload(bBuildAsync);

            // Apply Unity transform and possibly upload to Houdini Engine
            rootGO.transform.position = initialPosition;

            Debug.LogFormat("{0}: Created new HDA asset from {1} of type {2}.", HEU_Defines.HEU_NAME, filePath, asset.AssetType);

            return(rootGO);
        }
Пример #19
0
	private void ClearConnectedInputHDAs()
	{
	    int numInputs = _inputAssetInfos.Count;
	    for (int i = 0; i < numInputs; ++i)
	    {
		if (_inputAssetInfos[i] == null)
		{
		    continue;
		}

		HEU_HoudiniAssetRoot inputAssetRoot = _inputAssetInfos[i]._connectedGO != null ? _inputAssetInfos[i]._connectedGO.GetComponent<HEU_HoudiniAssetRoot>() : null;
		if (inputAssetRoot != null)
		{
		    _parentAsset.DisconnectFromUpstream(inputAssetRoot._houdiniAsset);
		}

		_inputAssetInfos[i]._connectedGO = null;
		_inputAssetInfos[i]._connectedInputNodeID = HEU_Defines.HEU_INVALID_NODE_ID;
	    }
	}
		/// <summary>
		/// Get list of user selected Houdini assets root components in the scene.
		/// </summary>
		/// <returns>List of selected Houdini asset root components (HEU_HoudiniAssetRoot)</returns>
		public static HEU_HoudiniAssetRoot[] GetSelectedAssetRoots()
		{
			List<HEU_HoudiniAssetRoot> rootAssets = new List<HEU_HoudiniAssetRoot>();
#if UNITY_EDITOR
			Object[] selectedObjects = Selection.objects;
			foreach (Object obj in selectedObjects)
			{
				GameObject go = obj as GameObject;
				if (go != null)
				{
					HEU_HoudiniAssetRoot root = go.GetComponent<HEU_HoudiniAssetRoot>();
					if (root != null)
					{
						rootAssets.Add(root);
					}
				}
			}
#endif
			return rootAssets.ToArray();
		}
Пример #21
0
		private void ConnectInputAssetActor(HEU_SessionBase session)
		{
			if(IsInputAssetConnected())
			{
				Debug.LogWarning("Input asset already connected!");
				return;
			}

			HEU_HoudiniAssetRoot inputAssetRoot = _inputAsset != null ? _inputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
			if (inputAssetRoot != null && inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
			{
				_connectedNodeID = inputAssetRoot._houdiniAsset.AssetID;

				ConnectInputNode(session);

				_parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);

				_connectedInputAsset = _inputAsset;
			}
		}
Пример #22
0
		/// <summary>
		/// Force cook upstream connected asset if its not valid in given session.
		/// </summary>
		/// <param name="session"></param>
		public void CookUpstreamConnectedAsset(HEU_SessionBase session)
		{
			if(_inputObjectType == InputObjectType.HDA && IsInputAssetConnected())
			{
				HEU_HoudiniAssetRoot inputAssetRoot = _connectedInputAsset.GetComponent<HEU_HoudiniAssetRoot>();
				if (inputAssetRoot != null && !inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
				{
					inputAssetRoot._houdiniAsset.RequestCook(true, false, true, true);

					// Update the _connectNodeID to the connected asset's ID since it might have changed during cook
					if(_connectedNodeID != HEU_Defines.HEU_INVALID_NODE_ID)
					{
						HAPI_NodeId otherAssetID = inputAssetRoot._houdiniAsset != null ? inputAssetRoot._houdiniAsset.AssetID : HEU_Defines.HEU_INVALID_NODE_ID;
						if(otherAssetID != _connectedNodeID)
						{
							_connectedNodeID = otherAssetID;
						}
					}
				}
			}
		}
Пример #23
0
		//	LOGIC -----------------------------------------------------------------------------------------------------

		private void OnEnable()
		{
			_reloadhdaIcon = Resources.Load("heu_reloadhdaIcon") as Texture2D;
			_recookhdaIcon = Resources.Load("heu_recookhdaIcon") as Texture2D;
			_bakegameobjectIcon = Resources.Load("heu_bakegameobjectIcon") as Texture2D;
			_bakeprefabIcon = Resources.Load("heu_bakeprefabIcon") as Texture2D;
			_bakeandreplaceIcon = Resources.Load("heu_bakeandreplaceIcon") as Texture2D;
			_removeheIcon = Resources.Load("heu_removeheIcon") as Texture2D;
			_duplicateAssetIcon = Resources.Load("heu_duplicateassetIcon") as Texture2D;

			_reloadhdaContent = new GUIContent("  Reload Asset", _reloadhdaIcon, "Reset and reload the asset in Houdini. Parameter values are reset to default, and material overrides are removed.");
			_recookhdaContent = new GUIContent("  Recook Asset", _recookhdaIcon, "Force recook of the asset in Houdini with the current parameter values and specified input data. Updates asset if changed in Houdini.");
			_bakegameobjectContent = new GUIContent("  Bake GameObject", _bakegameobjectIcon, "Bakes the output to a new GameObject. Meshes and Materials are copied.");
			_bakeprefabContent = new GUIContent("  Bake Prefab", _bakeprefabIcon, "Bakes the output to a new Prefab. Meshes and Materials are copied.");
			_bakeandreplaceContent = new GUIContent("  Bake Update", _bakeandreplaceIcon, "Update existing GameObject(s) and Prefab(s). Generated components, meshes, and materials are updated.");
			_removeheContent = new GUIContent("  Keep Only Output", _removeheIcon, "Remove HDA_Data and the Houdini Asset Root object, and leave just the output GameObject.");
			_duplicateContent = new GUIContent("  Duplicate Asset", _duplicateAssetIcon, "Safe duplication of this asset to create an exact copy. The asset is duplicated in Houdini. All data is copied over.");

			// Get the root gameobject, and the HDA bound to it
			_houdiniAssetRoot = target as HEU_HoudiniAssetRoot;
			TryAcquiringAsset();
		}
Пример #24
0
	//	LOGIC -----------------------------------------------------------------------------------------------------

	private void OnEnable()
	{
	    _reloadhdaIcon = Resources.Load("heu_reloadhdaIcon") as Texture2D;
	    _recookhdaIcon = Resources.Load("heu_recookhdaIcon") as Texture2D;
	    _bakegameobjectIcon = Resources.Load("heu_bakegameobjectIcon") as Texture2D;
	    _bakeprefabIcon = Resources.Load("heu_bakeprefabIcon") as Texture2D;
	    _bakeandreplaceIcon = Resources.Load("heu_bakeandreplaceIcon") as Texture2D;
	    _removeheIcon = Resources.Load("heu_removeheIcon") as Texture2D;
	    _duplicateAssetIcon = Resources.Load("heu_duplicateassetIcon") as Texture2D;
	    _resetParamIcon = Resources.Load("heu_resetparametersIcon") as Texture2D;

	    _reloadhdaContent = new GUIContent("  Rebuild  ", _reloadhdaIcon, "Reload the asset in Houdini and cook it. Current parameter values and input objects will be re-applied. Material overrides will be removed.");
	    _recookhdaContent = new GUIContent("  Recook   ", _recookhdaIcon, "Force recook of the asset in Houdini with the current parameter values and specified input data. Updates asset if changed in Houdini.");
	    _bakegameobjectContent = new GUIContent("  GameObject", _bakegameobjectIcon, "Bakes the output to a new GameObject. Meshes and Materials are copied.");
	    _bakeprefabContent = new GUIContent("  Prefab", _bakeprefabIcon, "Bakes the output to a new Prefab. Meshes and Materials are copied.");
	    _bakeandreplaceContent = new GUIContent("  Update", _bakeandreplaceIcon, "Update existing GameObject(s) and Prefab(s). Generated components, meshes, and materials are updated.");
	    _removeheContent = new GUIContent("  Keep Only Output", _removeheIcon, "Remove Houdini Engine data (HDA_Data, Houdini Asset Root object), and leave just the generated Unity data (meshes, materials, instances, etc.).");
	    _duplicateContent = new GUIContent("  Duplicate", _duplicateAssetIcon, "Safe duplication of this asset to create an exact copy. The asset is duplicated in Houdini. All data is copied over.");
	    _resetParamContent = new GUIContent("  Reset All", _resetParamIcon, "Reset all parameters, materials, and inputs to their HDA default values, clear cache, reload HDA, cook, and generate output.");

	    // Get the root gameobject, and the HDA bound to it
	    _houdiniAssetRoot = target as HEU_HoudiniAssetRoot;
	    TryAcquiringAsset();
	}
Пример #25
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))
						{
							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;
		}
Пример #26
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);
			}
		}
Пример #27
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());
			}
		}
Пример #28
0
	private static bool DrawBakeSection(HEU_HoudiniAssetRoot assetRoot, 
	    SerializedObject assetRootSerializedObject,
	    HEU_HoudiniAsset asset, SerializedObject assetObject,
	    ref HEU_HoudiniAsset.AssetBuildAction pendingBuildAction)
	{
	    bool bSkipAutoCook = false;

	    HEU_EditorUI.BeginSection();
	    {
		SerializedProperty showBakeProperty = assetObject.FindProperty("_showBakeSection");

		showBakeProperty.boolValue = HEU_EditorUI.DrawFoldOut(showBakeProperty.boolValue, "BAKE");
		if (showBakeProperty.boolValue)
		{
		    // Bake -> New Instance, New Prefab, Existing instance or prefab

		    using (var hs = new EditorGUILayout.HorizontalScope(_mainBoxStyle))
		    {
			if (GUILayout.Button(_bakegameobjectContent, _mainButtonStyle))
			{
			    asset.BakeToNewStandalone();
			}

			GUILayout.Space(_mainButtonSeparatorDistance);

			if (GUILayout.Button(_bakeprefabContent, _mainButtonStyle))
			{
			    asset.BakeToNewPrefab();
			}
		    }

		    using (var vs = new EditorGUILayout.VerticalScope(_mainBoxStyle))
		    {
			if (GUILayout.Button(_removeheContent, _mainButtonStyle))
			{
			    pendingBuildAction = HEU_HoudiniAsset.AssetBuildAction.STRIP_HEDATA;
			    bSkipAutoCook = true;
			}
		    }

		    using (var hs2 = new EditorGUILayout.VerticalScope(_mainBoxStyle))
		    {
			if (GUILayout.Button(_bakeandreplaceContent, _mainCentredButtonStyle))
			{
			    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(_mainButtonSetStyle))
			{
			    SerializedProperty bakeTargetsProp = assetRootSerializedObject.FindProperty("_bakeTargets");
			    if (bakeTargetsProp != null)
			    {
				EditorGUILayout.PropertyField(bakeTargetsProp, _dragAndDropField, true);
			    }
			}
		    }
		}
	    }
	    HEU_EditorUI.EndSection();

	    HEU_EditorUI.DrawSeparator();

	    return bSkipAutoCook;
	}
Пример #29
0
		public void UploadInput(HEU_SessionBase session)
		{
			if (_nodeID == HEU_Defines.HEU_INVALID_NODE_ID)
			{
				Debug.LogErrorFormat("Input Node ID is invalid. Unable to upload input. Try recooking.");
				return;
			}

			if(_pendingInputObjectType != _inputObjectType)
			{
				ChangeInputType(session, _pendingInputObjectType);
			}

			if(_inputObjectType == InputObjectType.UNITY_MESH)
			{
				if(_inputObjects == null || _inputObjects.Count == 0)
				{
					DisconnectAndDestroyInputAssets(session);
				}
				else
				{
					DisconnectAndDestroyInputAssets(session);

					bool bResult = HEU_InputUtility.CreateInputNodeWithMultiObjects(session, _nodeID, ref _connectedNodeID, ref _inputObjects, ref _inputObjectsConnectedAssetIDs, _keepWorldTransform);
					if(!bResult)
					{
						DisconnectAndDestroyInputAssets(session);
						return;
					}

					ConnectInputNode(session);

					if(!UploadObjectMergeTransformType(session))
					{
						Debug.LogErrorFormat("Failed to upload object merge transform type!");
						return;
					}

					if (!UploadObjectMergePackGeometry(session))
					{
						Debug.LogErrorFormat("Failed to upload object merge pack geometry value!");
						return;
					}
				}
			}
			else if(_inputObjectType == InputObjectType.HDA)
			{
				// Connect HDA. Note only 1 connection supported.

				if (IsInputAssetConnected())
				{
					DisconnectInputAssetActor(session);
				}

				if (_inputAsset != null)
				{
					HEU_HoudiniAssetRoot inputAssetRoot = _inputAsset.GetComponent<HEU_HoudiniAssetRoot>();
					if(inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
					{
						if (!inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
						{
							// Force a recook if its not valid (in case it hasn't been loaded into the session)
							inputAssetRoot._houdiniAsset.RequestCook(true, false, true, true);
						}

						ConnectInputAssetActor(session);
					}
					else
					{
						Debug.LogWarningFormat("The input GameObject {0} is not a valid HDA asset.", _inputAsset.name);
					}
				}
			}
			//else if (_inputObjectType == InputObjectType.CURVE)
			//{
				// TODO INPUT NODE - create new Curve SOP (add HEU_Curve here?)
			//}
			else
			{
				Debug.LogErrorFormat("Unsupported input type {0}. Unable to upload input.", _inputObjectType);
			}

			RequiresUpload = false;
			RequiresCook = true;

			ClearUICache();
		}
Пример #30
0
		public void LoadPreset(HEU_SessionBase session, HEU_InputPreset inputPreset)
		{
			ResetInputNode(session);

			ChangeInputType(session, inputPreset._inputObjectType);

			if (inputPreset._inputObjectType == HEU_InputNode.InputObjectType.UNITY_MESH)
			{
				int numObjects = inputPreset._inputObjectPresets.Count;
				for (int i = 0; i < numObjects; ++i)
				{
					if (!string.IsNullOrEmpty(inputPreset._inputObjectPresets[i]._gameObjectName))
					{
						GameObject inputGO = null;
						if (inputPreset._inputObjectPresets[i]._isSceneObject)
						{
							inputGO = HEU_GeneralUtility.GetGameObjectByNameInScene(inputPreset._inputObjectPresets[i]._gameObjectName);
						}
						else
						{
							// Use the _gameObjectName as path to find in scene
							inputGO = HEU_AssetDatabase.LoadAssetAtPath(inputPreset._inputObjectPresets[i]._gameObjectName, typeof(GameObject)) as GameObject;
							if(inputGO == null)
							{
								Debug.LogErrorFormat("Unable to find input at {0}", inputPreset._inputObjectPresets[i]._gameObjectName);
							}
						}

						if (inputGO != null)
						{
							HEU_InputObjectInfo inputObject = AddInputObjectAtEnd(inputGO);
							inputObject._useTransformOffset = inputPreset._inputObjectPresets[i]._useTransformOffset;
							inputObject._translateOffset = inputPreset._inputObjectPresets[i]._translateOffset;
							inputObject._rotateOffset = inputPreset._inputObjectPresets[i]._rotateOffset;
							inputObject._scaleOffset = inputPreset._inputObjectPresets[i]._scaleOffset;
						}
						else
						{
							Debug.LogWarningFormat("Gameobject with name {0} not found. Unable to set input object.", inputPreset._inputAssetName);
						}
					}
				}
			}
			else if (inputPreset._inputObjectType == HEU_InputNode.InputObjectType.HDA)
			{
				if (!string.IsNullOrEmpty(inputPreset._inputAssetName))
				{
					GameObject inputAsset = GameObject.Find(inputPreset._inputAssetName);
					if (inputAsset != null)
					{
						HEU_HoudiniAssetRoot inputAssetRoot = inputAsset != null ? inputAsset.GetComponent<HEU_HoudiniAssetRoot>() : null;
						if (inputAssetRoot != null && inputAssetRoot._houdiniAsset != null)
						{
							// Need to reconnect and make sure connected asset is in this session

							_inputAsset = inputAsset;

							if (!inputAssetRoot._houdiniAsset.IsAssetValidInHoudini(session))
							{
								inputAssetRoot._houdiniAsset.RequestCook(true, false, true, true);
							}

							_connectedNodeID = inputAssetRoot._houdiniAsset.AssetID;

							_parentAsset.ConnectToUpstream(inputAssetRoot._houdiniAsset);

							_connectedInputAsset = _inputAsset;
						}
						else
						{
							Debug.LogErrorFormat("Input HDA with name {0} is not a valid asset (missing components). Unable to set input asset.", inputPreset._inputAssetName);
						}
					}
					else
					{
						Debug.LogWarningFormat("Game with name {0} not found. Unable to set input asset.", inputPreset._inputAssetName);
					}
				}
			}

			KeepWorldTransform = inputPreset._keepWorldTransform;
			PackGeometryBeforeMerging = inputPreset._packGeometryBeforeMerging;

			RequiresUpload = true;

			ClearUICache();
		}