| public static GetDefaultSession ( ) : HEU_SessionBase | ||
| Résultat | 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();
}
