/// <summary>
/// Save given session to a HIP file.
/// The user will be prompted with Unity's file dialog to choose HIP file location.
/// </summary>
/// <param name="bLockNodes">Whether to lock nodes in HIP file so as not to recook them on load</param>
/// <param name="session">Session to save out. If null, uses default session.</param>
/// <returns>True if successfully saved session</returns>
public static bool SaveSessionToHIP(bool bLockNodes, HEU_SessionBase session = null)
{
if(session == null || !session.IsSessionValid())
{
session = GetOrCreateDefaultSession();
if (session == null || !session.IsSessionValid())
{
session.SetSessionErrorMsg("No valid session found. Unable to save session!", true);
return false;
}
}
#if UNITY_EDITOR
string fileExt = "hip";
HAPI_License license = GetCurrentLicense(false);
if (license == HAPI_License.HAPI_LICENSE_HOUDINI_INDIE || license == HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE)
{
fileExt = "hiplc";
}
string filePath = UnityEditor.EditorUtility.SaveFilePanel("Save HIP File", "", "hscene", fileExt);
if(!string.IsNullOrEmpty(filePath))
{
return session.SaveHIPFile(filePath, bLockNodes);
}
#else
session.SetSessionErrorMsg("Save session only supported in Unity Editor!", true);
#endif
return false;
}
/// <summary>
/// Draw Houdini Engine license info.
/// </summary>
private void DrawLicenseInfo()
{
HAPI_License license = HEU_SessionManager.GetCurrentLicense(false);
if (license == HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE)
{
HEU_EditorUI.DrawSeparator();
GUIStyle labelStyle = new GUIStyle(GUI.skin.label);
labelStyle.fontStyle = FontStyle.Bold;
labelStyle.normal.textColor = HEU_EditorUI.IsEditorDarkSkin() ? Color.yellow : Color.red;
EditorGUILayout.LabelField("Houdini Engine Indie - For Limited Commercial Use Only", labelStyle);
HEU_EditorUI.DrawSeparator();
}
}
public static void saveHoudiniScene(bool lock_nodes)
{
HAPI_License license = HoudiniHost.getCurrentLicense();
string ext = "hip";
if (license == HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE ||
license == HAPI_License.HAPI_LICENSE_HOUDINI_INDIE)
{
ext = "hiplc";
}
string hip_file_path = EditorUtility.SaveFilePanel("Save HIP File", "", "hscene", ext);
if (hip_file_path != "")
{
HoudiniHost.saveScene(hip_file_path, lock_nodes);
}
}
/// <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
}
public static void displayHoudiniEngineInstallInfo()
{
#if !UNITY_EDITOR
#pragma warning disable 0219
#endif // !UNITY_EDITOR
string installed_version_msg = "";
string dialog_title = "";
string license_info = "License Type Acquired: ";
if (isInstallationOk())
{
int houdini_major = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_MAJOR);
int houdini_minor = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_MINOR);
int houdini_build = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_BUILD);
int houdini_patch = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_PATCH);
int houdini_engine_major = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MAJOR);
int houdini_engine_minor = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MINOR);
int houdini_engine_api = getEnvInt(HAPI_EnvIntType.HAPI_ENVINT_VERSION_HOUDINI_ENGINE_API);
installed_version_msg =
"Installed Houdini Version: " +
houdini_major + "." +
houdini_minor + "." +
houdini_build +
(houdini_patch > 0 ? "." + houdini_patch : "") + "\n" +
"Installed Houdini Engine Version: " +
houdini_engine_major + "." +
houdini_engine_minor + "." +
houdini_engine_api + "\n\n" +
"Houdini Binaries Path: " + HoudiniSetPath.prHoudiniPath + "\n\n" +
"Houdini RPC Server Executable: " + prServerExecutablePath + "\n" +
"Houdini RPC Server Process ID: " + prProcessID.ToString() + "\n" +
"Houdini RPC Client Module: " + prLibraryPath + "\n" +
"Houdini RPC Pipe Name: " + prPipeName;
dialog_title = "Houdini Engine Installation Info";
HAPI_License houdini_license_type = getCurrentLicense();
switch (houdini_license_type)
{
case HAPI_License.HAPI_LICENSE_NONE: license_info += "None"; break;
case HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE: license_info += "Houdini Engine"; break;
case HAPI_License.HAPI_LICENSE_HOUDINI: license_info += "Houdini (Escape)"; break;
case HAPI_License.HAPI_LICENSE_HOUDINI_FX: license_info += "Houdini FX"; break;
case HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE: license_info += "Houdini Engine Indie"; break;
case HAPI_License.HAPI_LICENSE_HOUDINI_INDIE: license_info += "Houdini Indie"; break;
default: license_info += "Unknown"; break;
}
}
else
{
#if UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR)
installed_version_msg =
"Reason for Installation Detection Failure: " + prLastInitializationError;
#else
installed_version_msg =
"Reason for Installation Detection Failure: Unsupported Platform\n" +
HoudiniConstants.HAPI_UNSUPPORTED_PLATFORM_MSG;
#endif // UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR )
dialog_title = "No Houdini Engine Installed";
license_info += "Unknown";
}
#if UNITY_EDITOR && (UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
string path_var = "";
path_var = System.Environment.GetEnvironmentVariable("PATH", System.EnvironmentVariableTarget.Process);
#if UNITY_EDITOR_WIN
path_var = path_var.Replace(";", "\n");
#elif UNITY_EDITOR_OSX
path_var = path_var.Replace(":", "\n");
#endif // UNITY_EDITOR_WIN
#endif // UNITY_EDITOR_WIN || UNITY_EDITOR_OSX
string full_message =
"Required Houdini Version: " +
HoudiniVersion.HOUDINI_MAJOR + "." +
HoudiniVersion.HOUDINI_MINOR + "." +
HoudiniVersion.HOUDINI_BUILD + "\n" +
"Required Houdini Engine Version: " +
HoudiniVersion.HOUDINI_ENGINE_MAJOR + "." +
HoudiniVersion.HOUDINI_ENGINE_MINOR + "." +
HoudiniVersion.HOUDINI_ENGINE_API + "\n\n" +
installed_version_msg +
"\n\n" +
license_info +
#if UNITY_EDITOR && (UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
"\n\n" +
"PATH Variable: \n" +
path_var +
#endif // UNITY_EDITOR && ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
"";
Debug.Log(full_message);
#if UNITY_EDITOR
EditorUtility.DisplayDialog(dialog_title, full_message, "Ok");
#endif // UNITY_EDITOR
#if !UNITY_EDITOR
#pragma warning restore 0219
#endif // !UNITY_EDITOR
}
public void OnGUI()
{
bool gui_enable = GUI.enabled;
#if !(UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
HoudiniGUI.help(HoudiniConstants.HAPI_UNSUPPORTED_PLATFORM_MSG, MessageType.Info);
GUI.enabled = false;
#else
if (!HoudiniHost.isInstallationOk())
{
HoudiniGUI.help(
HoudiniHost.getMissingEngineInstallHelpString(), MessageType.Info);
GUI.enabled = false;
}
#endif // !( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
if (GUILayout.Button(HoudiniGUIUtility.myLoadAssetLabel))
{
string asset_file_path = HoudiniGUIUtility.promptForOTLPath();
HoudiniAssetUtility.instantiateAsset(asset_file_path);
}
if (GUILayout.Button(HoudiniGUIUtility.myLoadHipLabel))
{
string hip_file_path = HoudiniGUIUtility.promptForHIPPath();
HoudiniAssetUtility.loadHipFile(hip_file_path);
}
HoudiniGUI.separator();
if (GUILayout.Button(HoudiniGUIUtility.mySaveHoudiniSceneLabel))
{
HAPI_License license = HoudiniHost.getCurrentLicense();
string ext = "hip";
if (license == HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE ||
license == HAPI_License.HAPI_LICENSE_HOUDINI_INDIE)
{
ext = "hiplc";
}
string hip_file_path = EditorUtility.SaveFilePanel("Save HIP File", "", "hscene", ext);
if (hip_file_path != "")
{
HoudiniHost.saveScene(hip_file_path, myLockNodesOnHipSave);
}
}
{
bool undo_value = myLockNodesOnHipSave;
HoudiniGUI.toggle(
"lock_nodes", "Lock Nodes On Scene Save",
ref myLockNodesOnHipSave, null, ref undo_value);
}
HoudiniGUI.separator();
if (GUILayout.Button("Check for New Untracked Asset Nodes"))
{
HoudiniAssetUtility.checkForNewAssets();
}
HoudiniGUI.separator();
if (HoudiniGUI.floatField("global_time", "Global Time", ref myTime, null, ref myTime))
{
HoudiniHost.setTime(myTime);
}
HoudiniGUI.separator();
string path = Application.dataPath;
myScrollPosition = GUILayout.BeginScrollView(myScrollPosition);
if (GUILayout.Button("Instantiate Core Assets"))
{
try
{
DirectoryInfo core = new DirectoryInfo(path + "//OTLs/Core");
if (!core.Exists)
{
throw new HoudiniError("Project/Assets/OTLs/Core directory does not exist!");
}
foreach (FileInfo fi in core.GetFiles())
{
if (fi.Extension == ".otl")
{
loadOTL(fi);
}
}
}
catch (System.Exception e)
{
Debug.LogError("Directory navigation failed: " + e.ToString());
}
}
#if (UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
DirectoryInfo di = new DirectoryInfo(path + "//OTLs");
try
{
if (!di.Exists)
{
throw new HoudiniError("Project/Assets/OTLs directory does not exist!");
}
foreach (DirectoryInfo child_directory in di.GetDirectories())
{
OTLDirectory otlDir = null;
foreach (OTLDirectory existingOTLDir in myOTLDirectories)
{
if (existingOTLDir.myDirectoryName == child_directory.Name)
{
otlDir = existingOTLDir;
break;
}
}
if (otlDir == null)
{
otlDir = new OTLDirectory();
otlDir.myDirectoryName = child_directory.Name;
otlDir.myDirectoryPath = child_directory.FullName;
otlDir.myExpanded = false;
myOTLDirectories.Add(otlDir);
}
otlDir.myExpanded =
EditorGUILayout.Foldout(otlDir.myExpanded, new GUIContent(otlDir.myDirectoryName));
if (otlDir.myDirectoryName == "Core")
{
otlDir.myExpanded = true;
}
if (otlDir.myExpanded)
{
DirectoryInfo dirContents = new DirectoryInfo(otlDir.myDirectoryPath);
foreach (FileInfo fi in dirContents.GetFiles())
{
if (fi.Extension == ".otl")
{
genOTLEntry(fi);
}
}
}
}
}
catch (System.Exception e)
{
Debug.LogError("Directory navigation failed: " + e.ToString());
}
#endif // ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
GUILayout.EndScrollView();
GUI.enabled = gui_enable;
}
