public static GetDefaultSession ( ) : HEU_SessionBase | ||
return | HEU_SessionBase |
/// <summary> /// Load a NodeSync file and create its construct in Unity. /// </summary> /// <param name="filePath">Path to the NodeSync file</param> /// <param name="name">Name of the NodeSync node</param> void CreateNodeSyncFromFile(string filePath, string name) { HEU_SessionBase session = HEU_SessionManager.GetDefaultSession(); if (session == null || !session.IsSessionValid()) { return; } HAPI_NodeId parentNodeID = -1; string nodeName = name; HAPI_NodeId newNodeID = -1; // This loads the node network from file, and returns the node that was created // with newNodeID. It is either a SOP object, or a subnet object. // The actual loader (HEU_ThreadedTaskLoadGeo) will deal with either case. if (!session.LoadNodeFromFile(filePath, parentNodeID, nodeName, true, out newNodeID)) { Log(string.Format("Failed to load node network from file: {0}.", filePath)); return; } // Wait until finished if (!HEU_HAPIUtility.ProcessHoudiniCookStatus(session, nodeName)) { Log(string.Format("Failed to cook loaded node with name: {0}.", nodeName)); return; } GameObject newGO = new GameObject(nodeName); HEU_NodeSync nodeSync = newGO.AddComponent <HEU_NodeSync>(); nodeSync.InitializeFromHoudini(session, newNodeID, nodeName, filePath); }
public static void CreateNodeSync(HEU_SessionBase session, string opName, string nodeNabel) { if (session == null) { session = HEU_SessionManager.GetDefaultSession(); } if (session == null || !session.IsSessionValid()) { return; } HAPI_NodeId newNodeID = -1; HAPI_NodeId parentNodeId = -1; if (!session.CreateNode(parentNodeId, opName, nodeNabel, true, out newNodeID)) { Debug.LogErrorFormat("Unable to create merge SOP node for connecting input assets."); return; } if (parentNodeId == -1) { // When creating a node without a parent, for SOP nodes, a container // geometry object will have been created by HAPI. // In all cases we want to use the node ID of that object container // so the below code sets the parent's node ID. // But for SOP/subnet we actually do want the subnet SOP node ID // hence the useSOPNodeID argument here is to override it. bool useSOPNodeID = opName.Equals("SOP/subnet"); HAPI_NodeInfo nodeInfo = new HAPI_NodeInfo(); if (!session.GetNodeInfo(newNodeID, ref nodeInfo)) { return; } if (nodeInfo.type == HAPI_NodeType.HAPI_NODETYPE_SOP) { if (!useSOPNodeID) { newNodeID = nodeInfo.parentId; } } else if (nodeInfo.type != HAPI_NodeType.HAPI_NODETYPE_OBJ) { Debug.LogErrorFormat("Unsupported node type {0}", nodeInfo.type); return; } } GameObject newGO = new GameObject(nodeNabel); HEU_NodeSync nodeSync = newGO.AddComponent<HEU_NodeSync>(); nodeSync.InitializeFromHoudini(session, newNodeID, nodeNabel, ""); }
/// <summary> /// Attempts to connect to running instance of Houdini with SessionSync enabled, /// with CONNECTION_ATTEMPT_RATE delay between attempts. Presuming that Houdini was just, /// launched this might take a few tries. Times out if unsuccessful after CONNECTION_TIME_OUT /// time. /// </summary> void UpdateConnecting(HEU_SessionSyncData syncData) { if (syncData == null || syncData.SyncStatus != HEU_SessionSyncData.Status.Connecting) { return; } // Attempt connection after waiting for a bit. if (Time.realtimeSinceStartup - syncData._timeLastUpdate >= CONNECTION_ATTEMPT_RATE) { if (InternalConnect(_sessionMode, _pipeName, HEU_PluginSettings.Session_Localhost, _port, HEU_PluginSettings.Session_AutoClose, HEU_PluginSettings.Session_Timeout, false)) { Log("Initializing..."); syncData.SyncStatus = HEU_SessionSyncData.Status.Initializing; try { HEU_SessionManager.InitializeDefaultSession(); HEU_SessionManager.GetDefaultSession().GetSessionData().SetSessionSync(syncData); syncData.SyncStatus = HEU_SessionSyncData.Status.Connected; Log("Connected!"); } catch (System.Exception ex) { syncData.SyncStatus = HEU_SessionSyncData.Status.Stopped; Log("Connection errored!"); Log(ex.ToString()); Debug.Log(ex.ToString()); } finally { // Clear this to get out of the connection state _connectionSyncData = null; } } else if (Time.realtimeSinceStartup - syncData._timeStartConnection >= CONNECTION_TIME_OUT) { syncData.SyncStatus = HEU_SessionSyncData.Status.Stopped; Log("Timed out trying to connect to Houdini." + "\nCheck if Houdini is running and SessionSync is enabled." + "\nCheck port or pipe name are correct by comparing with Houdini SessionSync panel."); } else { // Try again in a bit syncData._timeLastUpdate = Time.realtimeSinceStartup; } } }
/// <summary> /// Connect to a running instance of Houdini with SessionSync enabled. /// </summary> void ConnectSessionSync(HEU_SessionSyncData syncData) { if (syncData != null && syncData.SyncStatus != HEU_SessionSyncData.Status.Stopped) { return; } Log("Connecting To Houdini..."); HEU_SessionManager.RecreateDefaultSessionData(); if (syncData == null) { HEU_SessionData sessionData = HEU_SessionManager.GetSessionData(); if (sessionData != null) { syncData = sessionData.GetOrCreateSessionSync(); } else { syncData = new HEU_SessionSyncData(); } } bool result = InternalConnect(_sessionMode, _pipeName, HEU_PluginSettings.Session_Localhost, _port, HEU_PluginSettings.Session_AutoClose, HEU_PluginSettings.Session_Timeout, true); if (result) { try { HEU_SessionManager.InitializeDefaultSession(); HEU_SessionManager.GetDefaultSession().GetSessionData().SetSessionSync(syncData); syncData.SyncStatus = HEU_SessionSyncData.Status.Connected; Log("Connected!"); } catch (HEU_HoudiniEngineError ex) { syncData.SyncStatus = HEU_SessionSyncData.Status.Stopped; Log("Connection errored!"); Log(ex.ToString()); } } else { Log("Connection failed!"); } }
/// <summary> /// Return the current Houdini Engine session /// </summary> /// <returns></returns> public HEU_SessionBase GetHAPIPDGSession(bool bCreate = true) { if (bCreate) { return(HEU_SessionManager.GetOrCreateDefaultSession()); } else { return(HEU_SessionManager.GetDefaultSession()); } }
/// <summary> /// Upload the local HAPI_SessionSyncInfo to Houdini Engine. /// </summary> void UploadSessionSyncInfo(HEU_SessionBase session, HEU_SessionSyncData syncData) { if (session == null) { session = HEU_SessionManager.GetDefaultSession(); if (session == null || !session.IsSessionValid()) { return; } } session.SetSessionSyncInfo(ref syncData._syncInfo); }
/// <summary> /// Update the local SessionSync state while connected to Houdini. /// Synchronizes viewport if enabled. /// Disconnects if Houdini Engine session is not valid. /// </summary> void UpdateConnected(HEU_SessionSyncData syncData) { if (!HEU_PluginSettings.SessionSyncAutoCook) { return; } HEU_SessionBase session = HEU_SessionManager.GetDefaultSession(); if (session == null || !session.IsSessionValid() || !session.IsSessionSync()) { return; } if (session.ConnectionState == SessionConnectionState.CONNECTED) { // Get latest SessionSync info from Houdini Engine to synchronize // local state. DownloadSessionSyncInfo(null, syncData); // Use the above call to check validity of the session. // Note that once HAPI_IsSessionValid is improved, we might just use that. if (session.LastCallResultCode == HAPI_Result.HAPI_RESULT_INVALID_SESSION) { // Bad session Log("Session is invalid. Disconnecting."); Disconnect(syncData); return; } if (syncData._syncInfo.syncViewport) { UpdateViewport(session, syncData); } } else { if (syncData.SyncStatus == HEU_SessionSyncData.Status.Connected) { // Bad session Log("Session is invalid. Disconnecting."); Disconnect(syncData); } } }
void OnGUI() { HEU_SessionBase sessionBase = HEU_SessionManager.GetDefaultSession(); if (sessionBase == null) { return; } SetupUI(); if (_outputLogUIComponent != null) { float setHeight = this.position.size.y - 60; _outputLogUIComponent.SetHeight(setHeight); _outputLogUIComponent.OnGUI(sessionBase.GetCookLogString()); } }
/// <summary> /// Download the latest HAPI_SessionSyncInfo from Houdini Engine /// to update the local state. /// </summary> void DownloadSessionSyncInfo(HEU_SessionBase session, HEU_SessionSyncData syncData) { if (session == null) { session = HEU_SessionManager.GetDefaultSession(); if (session == null || !session.IsSessionValid()) { return; } } HAPI_SessionSyncInfo syncInfo = new HAPI_SessionSyncInfo(); if (session.GetSessionSyncInfo(ref syncInfo)) { if (HEU_HAPIUtility.IsSessionSyncEqual(ref syncInfo, ref syncData._syncInfo)) { Repaint(); } syncData._syncInfo = syncInfo; } }
void OnGUI() { HEU_SessionBase sessionBase = HEU_SessionManager.GetDefaultSession(); if (sessionBase == null) { return; } SetupUI(); if (_outputLogUIComponent != null) { float setHeight = this.position.size.y - _bottomPadding; _outputLogUIComponent.SetHeight(setHeight); _outputLogUIComponent.OnGUI(HEU_CookLogs.Instance.GetCookLogString()); } if (GUILayout.Button("Delete Log File")) { HEU_CookLogs.Instance.DeleteCookingFile(); } }
/// <summary> /// Unity callback to draw this UI. /// </summary> void OnGUI() { SetupUI(); HEU_SessionSyncData syncData = GetSessionSyncData(); EditorGUI.BeginChangeCheck(); bool bSessionStarted = (syncData != null && syncData.SyncStatus != HEU_SessionSyncData.Status.Stopped); bool bSessionCanStart = !bSessionStarted; if (bSessionCanStart) { // Only able to start a session if no session exists. HEU_SessionBase session = HEU_SessionManager.GetDefaultSession(); if (session != null && session.IsSessionValid()) { bSessionCanStart = false; } } HEU_HoudiniAssetUI.DrawHeaderSection(); // Draw SessionSync status. if (syncData != null) { if (syncData.SyncStatus == HEU_SessionSyncData.Status.Stopped) { if (!bSessionCanStart) { EditorGUILayout.LabelField("Another session already running. Disconnect it to start SessionSync."); } else { EditorGUILayout.LabelField("Status: " + syncData.SyncStatus); } } else { EditorGUILayout.LabelField("Status: " + syncData.SyncStatus); } } else { if (!bSessionCanStart) { EditorGUILayout.LabelField("Another session already running. Disconnect it to start SessionSync."); } else { EditorGUILayout.LabelField("No active session."); } } EditorGUILayout.Separator(); EditorGUI.indentLevel++; // Draw initial connection buttons (Start, Connect) using (new EditorGUILayout.HorizontalScope()) { using (new EditorGUI.DisabledScope(bSessionStarted || !bSessionCanStart)) { if (GUILayout.Button("Start Houdini")) { StartAndConnectToHoudini(syncData); } else if (GUILayout.Button("Connect to Houdini")) { ConnectSessionSync(syncData); } } } using (new EditorGUI.DisabledScope((syncData == null || !bSessionStarted) && bSessionCanStart)) { if (GUILayout.Button("Disconnect")) { Disconnect(syncData); } } EditorGUILayout.Separator(); // Draw Connection Settings EditorGUILayout.LabelField("Connection Settings"); using (new EditorGUI.DisabledScope(bSessionStarted)) { SessionMode newSessionMode = (SessionMode)EditorGUILayout.EnumPopup("Type", _sessionMode); if (_sessionMode != newSessionMode) { _sessionMode = newSessionMode; HEU_PluginSettings.Session_Mode = newSessionMode; } EditorGUI.indentLevel++; if (_sessionMode == SessionMode.Pipe) { string newPipeName = EditorGUILayout.DelayedTextField("Pipe Name", _pipeName); if (_pipeName != newPipeName) { HEU_PluginSettings.Session_PipeName = newPipeName; _pipeName = newPipeName; } } else if (_sessionMode == SessionMode.Socket) { int newPort = EditorGUILayout.DelayedIntField("Port", _port); HEU_PluginSettings.Session_Port = newPort; if (_port != newPort) { HEU_PluginSettings.Session_Port = newPort; _port = newPort; } } EditorGUI.indentLevel--; } EditorGUILayout.Separator(); // The rest requires syncData // Synchronization settings, and new nodes if (syncData != null) { using (new EditorGUI.DisabledScope(syncData.SyncStatus != HEU_SessionSyncData.Status.Connected)) { EditorGUILayout.LabelField("Synchronization Settings"); EditorGUI.indentLevel++; HEU_PluginSettings.SessionSyncAutoCook = HEU_EditorUI.DrawToggleLeft(HEU_PluginSettings.SessionSyncAutoCook, "Sync With Houdini Cook"); bool enableHoudiniTime = HEU_EditorUI.DrawToggleLeft(syncData._syncInfo.cookUsingHoudiniTime, "Cook Using Houdini Time"); if (syncData._syncInfo.cookUsingHoudiniTime != enableHoudiniTime) { syncData._syncInfo.cookUsingHoudiniTime = enableHoudiniTime; UploadSessionSyncInfo(null, syncData); } bool enableSyncViewport = HEU_EditorUI.DrawToggleLeft(syncData._syncInfo.syncViewport, "Sync Viewport"); if (syncData._syncInfo.syncViewport != enableSyncViewport) { syncData._syncInfo.syncViewport = enableSyncViewport; UploadSessionSyncInfo(null, syncData); } EditorGUI.indentLevel--; } EditorGUILayout.Separator(); EditorGUILayout.LabelField("New Node"); using (new EditorGUI.DisabledScope(syncData.SyncStatus != HEU_SessionSyncData.Status.Connected)) { EditorGUI.indentLevel++; syncData._newNodeName = EditorGUILayout.TextField("Name", syncData._newNodeName); syncData._nodeTypeIndex = EditorGUILayout.Popup("Type", syncData._nodeTypeIndex, _nodeTypesLabels); using (new EditorGUI.DisabledGroupScope(string.IsNullOrEmpty(syncData._newNodeName))) { using (new EditorGUILayout.VerticalScope()) { if (GUILayout.Button("Create")) { if (syncData._nodeTypeIndex >= 0 && syncData._nodeTypeIndex < 3) { HEU_NodeSync.CreateNodeSync(null, _nodeTypes[syncData._nodeTypeIndex], syncData._newNodeName); } else if (syncData._nodeTypeIndex == 3) { CreateCurve(syncData._newNodeName); } else if (syncData._nodeTypeIndex == 4) { CreateInput(syncData._newNodeName); } } if (GUILayout.Button("Load NodeSync")) { LoadNodeSyncDialog(syncData._newNodeName); } } } EditorGUI.indentLevel--; } EditorGUILayout.Separator(); // Log using (new EditorGUILayout.VerticalScope(_backgroundStyle)) { using (new EditorGUILayout.HorizontalScope()) { EditorGUILayout.PrefixLabel(_eventMessageContent); if (GUILayout.Button("Clear")) { ClearLog(); } } string logMsg = GetLog(); using (var scrollViewScope = new EditorGUILayout.ScrollViewScope(_eventMessageScrollPos, GUILayout.Height(120))) { _eventMessageScrollPos = scrollViewScope.scrollPosition; GUILayout.Label(logMsg, _eventMessageStyle); } } } EditorGUI.indentLevel--; if (EditorGUI.EndChangeCheck() && syncData != null) { HEU_SessionBase sessionBase = HEU_SessionManager.GetDefaultSession(); if (sessionBase != null) { HEU_SessionManager.SaveAllSessionData(); } } }
/// <summary> /// Return Houdini Engine installation and session information. /// Tries to use existing or creates new session to find information. /// </summary> /// <returns>String containing installation and session information.</returns> public static string GetHoudiniEngineInstallationInfo() { #if HOUDINIENGINEUNITY_ENABLED StringBuilder sb = new StringBuilder(); sb.AppendFormat("Required Houdini Version: {0}.{1}.{2}\nRequired Houdini Engine Version: {3}.{4}.{5}\n\n", HEU_HoudiniVersion.HOUDINI_MAJOR, HEU_HoudiniVersion.HOUDINI_MINOR, HEU_HoudiniVersion.HOUDINI_BUILD, HEU_HoudiniVersion.HOUDINI_ENGINE_MAJOR, HEU_HoudiniVersion.HOUDINI_ENGINE_MINOR, HEU_HoudiniVersion.HOUDINI_ENGINE_API); // Check if existing session is valid, or create a new session. Then query installation information. HEU_SessionBase session = HEU_SessionManager.GetDefaultSession(); if (session != null && session.IsSessionValid()) { int hMajor = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_MAJOR); int hMinor = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_MINOR); int hBuild = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_BUILD); int heuPatch = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_PATCH); int heuMajor = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MAJOR); int heuMinor = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MINOR); int heuAPI = session.GetEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_ENGINE_API); sb.AppendFormat("Installed Houdini Version: {0}.{1}.{2}{3}\n", hMajor, hMinor, hBuild, (heuPatch > 0) ? "." + heuPatch.ToString() : ""); sb.AppendFormat("Installed Houdini Engine Version: {0}.{1}.{2}\n\n", heuMajor, heuMinor, heuAPI); sb.AppendFormat("Houdini Binaries Path: {0}\n", HEU_Platform.GetHoudiniEnginePath() + HEU_HoudiniVersion.HAPI_BIN_PATH); sb.AppendFormat("Unity Plugin Version: {0}\n\n", HEU_HoudiniVersion.UNITY_PLUGIN_VERSION); HEU_SessionData sessionData = session.GetSessionData(); if (sessionData != null) { sb.AppendFormat("Session ID: {0}\n", sessionData.SessionID); sb.AppendFormat("Session Type: {0}\n", sessionData.SessionType); sb.AppendFormat("Process ID: {0}\n", sessionData.ProcessID); if (sessionData.SessionType == HAPI_SessionType.HAPI_SESSION_THRIFT) { sb.AppendFormat("Pipe name: {0}\n", sessionData.PipeName); } sb.AppendLine(); } sb.Append("License Type Acquired: "); HAPI_License license = HEU_SessionManager.GetCurrentLicense(false); switch (license) { case HAPI_License.HAPI_LICENSE_NONE: sb.Append("None\n"); break; case HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE: sb.Append("Houdini Engine\n"); break; case HAPI_License.HAPI_LICENSE_HOUDINI: sb.Append("Houdini (Escape)\n"); break; case HAPI_License.HAPI_LICENSE_HOUDINI_FX: sb.Append("Houdini FX\n"); break; case HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE: sb.Append("Houdini Engine Indie"); break; case HAPI_License.HAPI_LICENSE_HOUDINI_INDIE: sb.Append("Houdini Indie\n"); break; default: sb.Append("Unknown\n"); break; } } else // Unable to establish a session { sb.AppendLine("Unable to detect Houdini Engine installation."); sb.AppendLine("License Type Acquired: Unknown\n"); if (session != null) { sb.AppendLine("Failure possibly due to: " + session.GetLastSessionError()); } } sb.AppendLine(); sb.Append("PATH: \n" + GetEnvironmentPath()); Debug.Log(sb.ToString()); return(sb.ToString()); #else return(""); #endif }
private void OnClearLog() { HEU_SessionBase sessionBase = HEU_SessionManager.GetDefaultSession(); sessionBase.ClearCookLog(); }