private static void generateCurveSettings()
{
// Curve Primitive Type Default
{
int value = HoudiniHost.prCurvePrimitiveTypeDefault;
string[] labels = { "Polygon", "NURBS", "Bezier" };
int[] values = { 0, 1, 2 };
bool changed = HoudiniGUI.dropdown(
"curve_primitive_type_default", "Initial Type",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.curvePrimitiveTypeDefault);
if (changed)
{
HoudiniHost.prCurvePrimitiveTypeDefault = value;
}
}
// Curve Method Default
{
int value = HoudiniHost.prCurveMethodDefault;
string[] labels = { "CVs", "Breakpoints", "Freehand" };
int[] values = { 0, 1, 2 };
bool changed = HoudiniGUI.dropdown(
"curve_method_default", "Initial Method",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.curveMethodDefault);
if (changed)
{
HoudiniHost.prCurveMethodDefault = value;
}
}
}
public override void OnInspectorGUI()
{
if (myCurve == null)
{
return;
}
bool is_editable = myCurve.prEditable && HoudiniHost.isInstallationOk();
// We can only build or do anything if we can link to our libraries.
#if !(UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
is_editable = false;
HoudiniGUI.help(HoudiniConstants.HAPI_UNSUPPORTED_PLATFORM_MSG, MessageType.Info);
#else
if (!myCurve.prEditable)
{
HoudiniGUI.help("This curve is not editable.", MessageType.Info);
}
else if (!HoudiniHost.isInstallationOk())
{
HoudiniGUI.help(HoudiniHost.getMissingEngineInstallHelpString(), MessageType.Info);
}
#endif // !( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
bool gui_enable = GUI.enabled;
GUI.enabled = is_editable;
Object target = (Object)myTarget;
if (HoudiniGUI.objectField("target", "Target", ref target, typeof(GameObject)))
{
myTarget = (GameObject)target;
}
GUI.enabled = gui_enable;
}
protected void drawCookLog()
{
if (HoudiniGUI.button("get_cook_log", "Get Cook Log"))
{
myAsset.buildClientSide();
myLastCookLog = HoudiniHost.getStatusString(
HAPI_StatusType.HAPI_STATUS_COOK_RESULT,
HAPI_StatusVerbosity.HAPI_STATUSVERBOSITY_MESSAGES);
}
float width = (float)Screen.width - 60;
myCookLogScrollPosition = EditorGUILayout.BeginScrollView(
myCookLogScrollPosition, GUILayout.Height(200));
GUIStyle sel_label = new GUIStyle(GUI.skin.label);
sel_label.stretchWidth = true;
sel_label.wordWrap = true;
float height = sel_label.CalcHeight(
new GUIContent(myLastCookLog), width);
EditorGUILayout.SelectableLabel(
myLastCookLog, sel_label, GUILayout.Width(width),
GUILayout.Height(height));
EditorGUILayout.EndScrollView();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private
private static void generateGeneralSettings()
{
// Pin Size
{
float value = HoudiniHost.prPinSize;
bool changed = HoudiniGUI.floatField(
"pin_size", "Pin Size", ref value,
myUndoInfo, ref myUndoInfo.pinSize);
if (changed)
{
HoudiniHost.prPinSize = value;
HoudiniHost.repaint();
}
}
// Pin Colour
{
Color value = HoudiniHost.prPinColour;
bool changed = HoudiniGUI.colourField(
"pin_colour", "Pin Color", ref value,
myUndoInfo, ref myUndoInfo.pinColour);
if (changed)
{
HoudiniHost.prPinColour = value;
HoudiniHost.repaint();
}
}
// Auto pin
{
bool value = HoudiniHost.prAutoPinInstances;
bool changed = HoudiniGUI.toggle(
"auto_pin_instances", "Auto Pin Instances",
ref value, myUndoInfo,
ref myUndoInfo.autoPinInstances);
if (changed)
{
HoudiniHost.prAutoPinInstances = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Enable Support Warnings
{
bool value = HoudiniHost.prEnableSupportWarnings;
bool changed = HoudiniGUI.toggle(
"enable_support_warnings", "Enable Support Warnings",
ref value, myUndoInfo,
ref myUndoInfo.enableSupportWarnings);
if (changed)
{
HoudiniHost.prEnableSupportWarnings = value;
}
}
}
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 ) )
myUndoInfo = HoudiniHost.prHostUndoInfo;
myScrollPosition = GUILayout.BeginScrollView( myScrollPosition );
if ( GUILayout.Button( HoudiniGUIUtility.myRevertAllSettingsLabel ) )
{
if ( EditorUtility.DisplayDialog(
"Revert all settings?",
"Are you sure you want to revert ALL Houdini plugin settings?",
"Yes", "No" ) )
{
HoudiniHost.revertAllSettingsToDefaults();
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
GUIContent[] modes = new GUIContent[ 6 ];
modes[ 0 ] = new GUIContent( "General" );
modes[ 1 ] = new GUIContent( "Materials" );
modes[ 2 ] = new GUIContent( "Cooking" );
modes[ 3 ] = new GUIContent( "Geometry" );
modes[ 4 ] = new GUIContent( "Curves" );
modes[ 5 ] = new GUIContent( "Advanced" );
mySettingsTabSelection = GUILayout.Toolbar( mySettingsTabSelection, modes );
switch ( mySettingsTabSelection )
{
case 0: generateGeneralSettings(); break;
case 1: generateMaterialSettings(); break;
case 2: generateCookingSettings(); break;
case 3: generateGeometrySettings(); break;
case 4: generateCurveSettings(); break;
case 5: generateAdvancedSettings(); break;
default: Debug.LogError( "Invalid Settings Tab." ); break;
}
GUILayout.EndScrollView();
GUI.enabled = gui_enable;
}
public override void OnInspectorGUI()
{
HoudiniGUI.help("Values here are for debugging only and should not be modified directly.", MessageType.Info);
bool gui_enabled = GUI.enabled;
GUI.enabled = false;
DrawDefaultInspector();
GUI.enabled = gui_enabled;
}
private static void generateMaterialSettings()
{
// Gamma
{
float value = HoudiniHost.prGamma;
bool changed = HoudiniGUI.floatField(
"gamma", "Gamma", ref value,
myUndoInfo, ref myUndoInfo.gamma);
if (changed)
{
HoudiniHost.prGamma = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Don't Create Texture Files
{
bool value = HoudiniHost.prDontCreateTextureFiles;
bool changed = HoudiniGUI.toggle(
"dont_create_texture_files",
"Don't Create Texture Files (use in-memory textures)",
ref value, myUndoInfo, ref myUndoInfo.dontCreateTextureFiles);
if (changed)
{
HoudiniHost.prDontCreateTextureFiles = value;
HoudiniHost.repaint();
EditorUtility.DisplayDialog(
"Rebuilds Required",
"This change will take affect for new instantiations or rebuilds.\n" +
"A full Unity restart is recommended.",
"Ok");
}
}
// Extract Textures In Raw Format
{
bool value = HoudiniHost.prExtractTexturesInRawFormat;
bool was_gui_enabled = GUI.enabled;
GUI.enabled = HoudiniHost.prDontCreateTextureFiles;
bool changed = HoudiniGUI.toggle(
"extract_textures_in_raw_format",
"Extract Textures In Raw Format (only works for in-memory textures)",
ref value, myUndoInfo, ref myUndoInfo.extractTexturesInRawFormat);
if (changed)
{
HoudiniHost.prExtractTexturesInRawFormat = value;
HoudiniHost.repaint();
}
GUI.enabled = was_gui_enabled;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private
private void generateAssetBakeControls()
{
// Start Time
{
float value = myAsset.prBakeStartTime;
bool changed = HoudiniGUI.floatField(
"bake_start_time", "Start Time", ref value,
myUndoInfo, ref myUndoInfo.bakeStartTime);
if (changed)
{
myAsset.prBakeStartTime = value;
}
}
// End Time
{
float value = myAsset.prBakeEndTime;
bool changed = HoudiniGUI.floatField(
"bake_end_time", "End Time", ref value,
myUndoInfo, ref myUndoInfo.bakeEndTime);
if (changed)
{
myAsset.prBakeEndTime = value;
}
}
// Samples per second
{
int value = myAsset.prBakeSamplesPerSecond;
bool changed = HoudiniGUI.intField(
"bake_samples_per_second", "Samples Per Second", ref value,
1, 120, myUndoInfo, ref myUndoInfo.bakeSamplesPerSecond);
if (changed)
{
myAsset.prBakeSamplesPerSecond = value;
}
}
if (GUILayout.Button("Bake Animation"))
{
HoudiniProgressBar progress_bar = new HoudiniProgressBar();
progress_bar.prUseDelay = false;
myAsset.bakeAnimations(
myAsset.prBakeStartTime,
myAsset.prBakeEndTime,
myAsset.prBakeSamplesPerSecond,
myAsset.gameObject,
progress_bar);
progress_bar.clearProgressBar();
}
}
private void generatePaintToolGUI()
{
foreach (HoudiniGeoControl geo_control in myAssetOTL.prEditPaintGeos)
{
if (HoudiniGUI.button(geo_control.prGeoName, geo_control.prGeoName))
{
myAssetOTL.prActiveEditPaintGeo = geo_control;
myGeoAttributeManager = geo_control.prGeoAttributeManager;
myGeoAttributeManagerGUI = new HoudiniGeoAttributeManagerGUI(myGeoAttributeManager);
}
}
}
protected void createToggleForProperty(
string name, string label, string property_name,
ref bool undo_info_value, valueChangedFunc func,
bool global_overwrite, bool local_overwrite,
string local_overwrite_message)
{
bool gui_enabled = GUI.enabled;
try
{
PropertyInfo property = typeof(HoudiniAsset).GetProperty(property_name);
if (property == null)
{
throw new HoudiniErrorInvalidArgument(property_name + " is not a valid property of HAPI_Asset!");
}
if (property.PropertyType != typeof(bool))
{
throw new HoudiniErrorInvalidArgument(property_name + " is not a boolean!");
}
GUI.enabled = !global_overwrite && !local_overwrite && GUI.enabled;
if (global_overwrite)
{
label += " (overwritted by global setting)";
}
else if (local_overwrite)
{
label += local_overwrite_message;
}
bool value = ( bool )property.GetValue(myAsset, null);
bool is_bold = myParentPrefabAsset && ( bool )property.GetValue(myParentPrefabAsset, null) != value;
bool changed = HoudiniGUI.toggle(name, label, is_bold, ref value, myUndoInfo, ref undo_info_value);
if (changed)
{
property.SetValue(myAsset, value, null);
if (func != null)
{
func();
}
}
}
catch (System.Exception error)
{
Debug.LogError(
"Failed to create toggle for: " + label + "\n" +
error.ToString() + "\nSource: " + error.Source);
}
GUI.enabled = gui_enabled;
}
protected bool setTransformInput(int index)
{
if (myAsset.prUpStreamTransformObjects == null || myAsset.prUpStreamTransformObjects.Count <= 0)
{
return(false);
}
bool join_last = false;
bool no_label_toggle_last = true;
GameObject temp_obj = null;
HoudiniGUIParm trans_input = new HoudiniGUIParm("trans_input_" + index, myAsset.prTransInputNames[index]);
Object obj = (Object)myAsset.prUpStreamTransformObjects[index];
bool changed = HoudiniGUI.objectField(ref trans_input, ref obj, typeof(GameObject),
ref join_last, ref no_label_toggle_last, null, ref temp_obj);
if (changed)
{
if (!obj)
{
myAsset.prUpStreamTransformObjects[index] = null;
myAsset.removeTransformInput(index);
}
else
{
GameObject game_obj = (GameObject)obj;
myAsset.prUpStreamTransformObjects[index] = game_obj;
HoudiniAsset input_asset = game_obj.GetComponent <HoudiniAsset>();
if (input_asset)
{
myAsset.addAssetAsTransformInput(input_asset, index);
}
else
{
myAsset.removeTransformInput(index);
}
myAsset.buildClientSide();
}
}
return(changed);
}
protected void drawLicenseLogo()
{
if (HoudiniHost.getCurrentLicense() != HAPI_License.HAPI_LICENSE_HOUDINI_ENGINE_INDIE)
{
return;
}
HoudiniGUI.separator();
int skin = EditorPrefs.GetInt("UserSkin");
bool is_light_skin = skin == 0;
#if false
if (myDarkSkinLogo == null && is_dark_skin)
{
myDarkSkinLogo = Resources.Load <Texture2D>("hEngine_white_color");
}
if (myLightSkinLogo == null && is_light_skin)
{
myLightSkinLogo = Resources.Load <Texture2D>("hEngine_black_color");
}
Texture2D logo = (is_light_skin ? myLightSkinLogo : myDarkSkinLogo);
float pane_width = (float)Screen.width - 60;
float ratio = Mathf.Min(0.2f, pane_width / logo.width);
GUIStyle image_style = new GUIStyle(GUI.skin.label);
image_style.normal.background = logo;
image_style.imagePosition = ImagePosition.ImageAbove;
EditorGUILayout.LabelField(
"", image_style,
GUILayout.Height(logo.height * ratio),
GUILayout.Width(logo.width * ratio));
#endif
GUIStyle label_style = new GUIStyle(GUI.skin.label);
label_style.fontStyle = FontStyle.Bold;
label_style.normal.textColor = is_light_skin ? Color.red : Color.yellow;
EditorGUILayout.LabelField("Houdini Engine Indie - For Limited Commercial Use Only", label_style);
HoudiniGUI.separator();
}
protected bool generateAssetControl(int index, ref bool join_last, ref bool no_label_toggle_last)
{
if (myParms.prParms == null)
{
return(false);
}
if (myParms.prParms[index].invisible)
{
return(false);
}
bool changed = false;
HAPI_ParmInfo[] parms = myParms.prParms;
HAPI_ParmInfo parm = parms[index];
HAPI_ParmInfoStrings parm_strings = myParms.prParmInfoStrings[index];
int[] parm_int_values = myParms.prParmIntValues;
float[] parm_float_values = myParms.prParmFloatValues;
HoudiniGUIParm gui_parm = new HoudiniGUIParm(parm, parm_strings);
///////////////////////////////////////////////////////////////////////
// Integer Parameter
if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST)
{
changed = HoudiniGUI.multiparmField(
ref gui_parm, ref myDelayBuild, ref parm_int_values,
ref join_last, ref no_label_toggle_last);
}
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_INT)
{
if (parm.choiceCount > 0 && parm.choiceIndex >= 0)
{
// Draw popup (menu) field.
List <string> labels = new List <string>();
List <int> values = new List <int>();
// Go through our choices.
for (int i = 0; i < parm.choiceCount; ++i)
{
if (myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId != parm.id)
{
Debug.LogError("Parm choice parent parm id ("
+ myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId
+ ") not matching current parm id (" + parm.id + ")!\n"
+ "Choice index: " + (parm.choiceIndex + i) + ", "
+ "Choice count: " + parm.choiceCount);
}
labels.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].label);
values.Add(i);
}
changed = HoudiniGUI.dropdown(
ref gui_parm, ref parm_int_values,
labels.ToArray(), values.ToArray(),
ref join_last, ref no_label_toggle_last,
null, ref parm_int_values);
}
else
{
changed = HoudiniGUI.intField(
ref gui_parm, ref myDelayBuild, ref parm_int_values,
ref join_last, ref no_label_toggle_last, null,
ref parm_int_values);
} // if parm.choiceCount
} // if parm.type is INT
///////////////////////////////////////////////////////////////////////
// Float Parameter
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_FLOAT)
{
changed = HoudiniGUI.floatField(
ref gui_parm, ref myDelayBuild, ref parm_float_values,
ref join_last, ref no_label_toggle_last, null,
ref parm_float_values);
} // if parm.type is FLOAT
///////////////////////////////////////////////////////////////////////
// String Parameter
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_STRING)
{
if (parm.choiceCount > 0 && parm.choiceIndex >= 0)
{
// Draw popup (menu) field.
List <string> labels = new List <string>();
List <string> values = new List <string>();
// Go through our choices.
for (int i = 0; i < parm.choiceCount; ++i)
{
if (myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId != parm.id)
{
Debug.LogError(
"Parm choice parent parm id ("
+ myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId
+ ") not matching current parm id (" + parm.id + ")!\n"
+ "Choice index: " + (parm.choiceIndex + i) + ", "
+ "Choice count: " + parm.choiceCount);
}
labels.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].label);
values.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].value);
}
string[] values_temp = myParms.getParmStrings(parm);
gui_parm.valuesIndex = 0; // Since we're piping a de-handled temp array.
changed = HoudiniGUI.dropdown(
ref gui_parm, ref values_temp,
labels.ToArray(), values.ToArray(),
ref join_last, ref no_label_toggle_last,
null, ref values_temp);
if (changed)
{
myParms.setParmStrings(parm, values_temp);
}
}
else
{
string[] values = myParms.getParmStrings(parm);
// The given string array is only for this parm so we need to set the values index to 0.
gui_parm.valuesIndex = 0;
changed = HoudiniGUI.stringField(
ref gui_parm, ref myDelayBuild, ref values,
ref join_last, ref no_label_toggle_last, null,
ref values);
// Set the to be changed strings into the cache
if (changed)
{
myParms.setParmStrings(parm, values);
}
}
}
///////////////////////////////////////////////////////////////////////
// File Path Field
else if (parm.isPath())
{
string[] path = myParms.getParmStrings(parm);
if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_PATH_FILE_GEO)
{
gui_parm.label += " (geo)";
}
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_PATH_FILE_IMAGE)
{
gui_parm.label += " (image)";
}
// Asset ID might still be invalid here so don't fail if it is.
// It is invalid if the asset didn't cook yet after a scene load.
try
{
string file_pattern = parm.typeInfo;
if (file_pattern != "")
{
gui_parm.label += " (" + file_pattern + ")";
}
}
catch {}
HAPI_Permissions permissions = parm.permissions;
if (permissions == HAPI_Permissions.HAPI_PERMISSIONS_READ_ONLY)
{
gui_parm.label += " (read-only)";
changed = HoudiniGUI.fileOpenField(
ref gui_parm, ref myDelayBuild, ref path[0],
ref join_last, ref no_label_toggle_last);
}
else
{
if (permissions == HAPI_Permissions.HAPI_PERMISSIONS_WRITE_ONLY)
{
gui_parm.label += " (write-only)";
}
changed = HoudiniGUI.fileSaveField(
ref gui_parm, ref myDelayBuild, ref path[0],
ref join_last, ref no_label_toggle_last);
}
if (changed)
{
myParms.setParmStrings(parm, path);
}
}
///////////////////////////////////////////////////////////////////////
// Node Path Field
else if (parm.isNode())
{
// Asset ID might still be invalid here so don't fail if it is.
// It is invalid if the asset didn't cook yet after a scene load.
try
{
string op_filter = parm.typeInfo;
if (op_filter != "")
{
gui_parm.label += " (" + op_filter + ")";
}
}
catch {}
HAPI_ParmInput parm_input = myParms.prParmInputs[parm.id];
UnityEngine.Object temp_object = parm_input.inputObject;
GameObject undo_object = null;
changed = HoudiniGUI.objectField(
ref gui_parm, ref temp_object, typeof(GameObject),
ref join_last, ref no_label_toggle_last, null, ref undo_object);
if (changed)
{
parm_input.newInputObject = (GameObject)temp_object;
myParms.prParmInputs[index] = parm_input;
}
}
///////////////////////////////////////////////////////////////////////
// Toggle Parameter
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_TOGGLE)
{
changed = HoudiniGUI.toggle(
ref gui_parm, ref parm_int_values,
ref join_last, ref no_label_toggle_last,
null, ref parm_int_values);
}
///////////////////////////////////////////////////////////////////////
// Color Parameter
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_COLOR)
{
changed = HoudiniGUI.colourField(
ref gui_parm, ref myDelayBuild, ref parm_float_values,
ref join_last, ref no_label_toggle_last, null,
ref parm_float_values);
}
///////////////////////////////////////////////////////////////////////
// Button Parameter
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_BUTTON)
{
if (parm.choiceCount > 0 && parm.choiceIndex >= 0)
{
// Draw popup (menu) field.
List <string> labels = new List <string>();
List <int> values = new List <int>();
// Go through our choices.
for (int i = 0; i < parm.choiceCount; ++i)
{
if (myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId != parm.id)
{
Debug.LogError(
"Parm choice parent parm id ("
+ myParms.prParmChoiceLists[parm.choiceIndex + i].parentParmId
+ ") not matching current parm id (" + parm.id + ")!\n"
+ "Choice index: " + (parm.choiceIndex + i) + ", "
+ "Choice count: " + parm.choiceCount);
}
labels.Add(myParms.prParmChoiceInfoStrings[parm.choiceIndex + i].label);
values.Add(i);
}
changed = HoudiniGUI.dropdown(
ref gui_parm, ref parm_int_values,
labels.ToArray(), values.ToArray(),
ref join_last, ref no_label_toggle_last,
null, ref parm_int_values);
}
else
{
changed = HoudiniGUI.button(ref gui_parm, ref join_last, ref no_label_toggle_last);
}
}
///////////////////////////////////////////////////////////////////////
// Label
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_LABEL)
{
HoudiniGUI.label(ref gui_parm, ref join_last, ref no_label_toggle_last);
}
///////////////////////////////////////////////////////////////////////
// Separator
else if (parm.type == HAPI_ParmType.HAPI_PARMTYPE_SEPARATOR)
{
HoudiniGUI.separator();
}
if (myAsset.hasProgressBarBeenUsed() && parm.id == myParms.prLastChangedParmId)
{
// TODO: Set the focus back to this control since the progress bar would have stolen it.
}
if (changed)
{
myParms.prLastChangedParmId = parm.id;
}
return(changed);
}
public override void OnInspectorGUI()
{
myPartControl.prShowDisplayOptions =
HoudiniGUI.foldout("Display Options", myPartControl.prShowDisplayOptions, true);
if (myPartControl.prShowDisplayOptions)
{
{
if (HoudiniGUI.button("print_attribute_names", "Print Attribute Names"))
{
HoudiniAssetUtility.printAllAttributeNames(
myPartControl.prAssetId, myPartControl.prObjectId,
myPartControl.prGeoId, myPartControl.prPartId);
}
if (HoudiniGUI.button("print_group_info", "Print Group Info"))
{
HoudiniAssetUtility.printAllGroups(
myPartControl.prAssetId, myPartControl.prObjectId,
myPartControl.prGeoId, myPartControl.prPartId);
}
}
{ // Show Houdini Point Numbers
bool value = myPartControl.prShowPointNumbers;
bool undo_value = false;
bool changed = HoudiniGUI.toggle(
"show_point_numbers", "Show Houdini Point Numbers", ref value,
null, ref undo_value);
myPartControl.prShowPointNumbers = value;
if (changed)
{
EditorUtility.SetDirty(myPartControl);
}
}
}
myPartControl.prShowIntermediateResultControls =
HoudiniGUI.foldout("Intermediate Results", myPartControl.prShowIntermediateResultControls, true);
if (myPartControl.prShowIntermediateResultControls)
{
bool gui_enabled = GUI.enabled;
if (myPartControl.prGeoType != HAPI_GeoType.HAPI_GEOTYPE_INTERMEDIATE)
{
HoudiniGUI.help(
"Only specially marked intermediate results geometries can be edited.",
MessageType.Info);
GUI.enabled = false;
}
if (GUILayout.Button("Update Intermediate Result"))
{
MeshFilter mesh_filter = myPartControl.gameObject.GetComponent <MeshFilter>();
Mesh shared_mesh = mesh_filter.sharedMesh;
HoudiniPartControl part_control = myPartControl.gameObject.GetComponent <HoudiniPartControl>();
HoudiniAssetUtility.setMesh(
myPartControl.prAsset.prAssetId,
myPartControl.prObjectId,
myPartControl.prGeoId,
ref shared_mesh,
part_control,
null);
myPartControl.prAsset.buildClientSide();
}
if (GUILayout.Button("Clear Edits"))
{
HoudiniHost.revertGeo(
myPartControl.prAsset.prAssetId,
myPartControl.prObjectId,
myPartControl.prGeoId);
myPartControl.prAsset.buildClientSide();
}
GUI.enabled = gui_enabled;
}
myPartControl.prShowInfo =
HoudiniGUI.foldout("Info", myPartControl.prShowInfo, true);
if (myPartControl.prShowInfo)
{
HoudiniGUI.help("Values here are for debugging only and should not be modified directly.", MessageType.Info);
bool gui_enabled = GUI.enabled;
GUI.enabled = false;
DrawDefaultInspector();
GUI.enabled = gui_enabled;
}
}
public override void OnInspectorGUI()
{
try
{
myDelayBuild = false;
myParmChanges = false;
myFocusChanged = false;
Event current_event = Event.current;
bool commit_changes = false;
if (current_event.isKey && current_event.type == EventType.KeyUp && current_event.keyCode == KeyCode.Return)
{
commit_changes = true;
}
else if (
current_event.type == EventType.ValidateCommand &&
current_event.commandName == "UndoRedoPerformed")
{
performUndo();
}
///////////////////////////////////////////////////////////////////////
// Draw Asset Controls
bool is_editable = myParms.prEditable && HoudiniHost.isInstallationOk();
// We can only build or do anything if we can link to our libraries.
#if !( HAPI_ENABLE_RUNTIME )
is_editable = false;
HoudiniGUI.help(HoudiniConstants.HAPI_UNSUPPORTED_PLATFORM_MSG, MessageType.Info);
#else
if (!myParms.prEditable)
{
HoudiniGUI.help("The parameters on this node are readonly.", MessageType.Info);
}
else if (!HoudiniHost.isInstallationOk())
{
HoudiniGUI.help(HoudiniHost.getMissingEngineInstallHelpString(), MessageType.Info);
}
#endif // !( HAPI_ENABLE_RUNTIME )
bool gui_enable = GUI.enabled;
GUI.enabled = is_editable;
myParmChanges |= generateAssetControls();
GUI.enabled = gui_enable;
///////////////////////////////////////////////////////////////////////
// Apply Changes
// Only record undo info object if parameters are not being changed
// due to an undo/redo event.
bool record_undo = current_event.commandName != "UndoRedoPerformed";
applyChanges(commit_changes, record_undo);
}
catch (HoudiniErrorIgnorable) {}
catch (HoudiniError error)
{
Debug.LogError(error.ToString() + "\nSource: " + error.Source);
}
catch (System.Exception error)
{
Debug.LogError(error.ToString() + "\nSource: " + error.Source);
}
}
public override void OnInspectorGUI()
{
bool gui_enable = GUI.enabled;
// We can only build or do anything if we can link to our libraries.
#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 ) )
try
{
myDelayBuild = false;
myParmChanges = false;
///////////////////////////////////////////////////////////////////////
// Draw Game Object Controls
if (HoudiniHost.isAssetValid(myAsset.prAssetId, myAsset.prAssetValidationId) &&
(myAsset.prTransformInputCount > 0 || myAsset.prGeoInputCount > 0) &&
myAsset.prAssetSubType != HAPI_AssetSubType.HAPI_ASSETSUBTYPE_CURVE &&
!myAsset.isPrefab())
{
myAsset.prShowInputControls = HoudiniGUI.foldout("Inputs", myAsset.prShowInputControls, true);
if (myAsset.prShowInputControls)
{
if (myAsset.prHAPIAssetType == HAPI_AssetType.HAPI_ASSETTYPE_OBJ)
{
for (int ii = 0; ii < myAsset.prTransformInputCount; ++ii)
{
myParmChanges |= setTransformInput(ii);
}
}
if (myAsset.prUpStreamGeoObjects == null || myAsset.prUpStreamGeoAssets == null ||
myAsset.prUpStreamGeoObjects.Count <= 0 || myAsset.prUpStreamGeoAssets.Count <= 0)
{
return;
}
for (int input_index = 0; input_index < myAsset.prGeoInputCount; ++input_index)
{
bool join_last = false;
bool no_label_toggle_last = true;
HoudiniGUIParm geo_input = new HoudiniGUIParm(
"geo_input_" + input_index, myAsset.prGeoInputNames[input_index]);
Object obj = (Object)myAsset.prUpStreamGeoObjects[input_index];
myParmChanges |= HoudiniGUI.objectField(
ref geo_input, ref obj, typeof(GameObject), ref join_last, ref no_label_toggle_last);
if (myParmChanges || !myAsset.isGeoInputValid(input_index))
{
if (!obj)
{
myAsset.removeGeoInput(input_index);
myAsset.buildClientSide();
}
else
{
GameObject new_obj = (GameObject)obj;
myAsset.prUpStreamGeoObjects[input_index] = new_obj;
// Select the asset component (if it exists).
HoudiniAsset asset = new_obj.GetComponent <HoudiniAsset>();
// If we're selecting a specific object to input than try and
// get the object id. Note that by getting the HAPI_ObjectControl
// component we also cover the geo and part controls because
// they all inherit from HAPI_ObjectControl. The user can therefore
// drag any gameObject under the asset into another asset's
// input and have it all work.
int object_index = 0;
HoudiniObjectControl obj_control = new_obj.GetComponent <HoudiniObjectControl>();
if (obj_control)
{
object_index = obj_control.prObjectId;
asset = obj_control.prAsset;
}
if (asset == null)
{
myAsset.addGeoAsGeoInput(new_obj, input_index);
myAsset.buildClientSide();
}
else if (myAsset.prUpStreamGeoAssets[input_index] != asset)
{
if (myAsset == asset)
{
Debug.LogError("Can't connect an asset to itself!");
}
else
{
myAsset.addAssetAsGeoInput(asset, object_index, input_index);
myAsset.buildClientSide();
}
}
}
}
} // for
} // if
} // if
// Draw Cook Log Pane
myAsset.prShowCookLog = HoudiniGUI.foldout("Asset Cook Log", myAsset.prShowCookLog, true);
if (myAsset.prShowCookLog)
{
drawCookLog();
}
}
catch (HoudiniError e)
{
Debug.LogError(e.ToString());
}
GUI.enabled = gui_enable;
}
private void generateAssetInstanceControls()
{
HoudiniInstancerManager instancer_manager = myAssetOTL.gameObject.GetComponent <HoudiniInstancerManager>();
if (instancer_manager == null)
{
return;
}
List <HoudiniInstancerPersistentData> instancer_persistent_data = instancer_manager.prInstancerPersistentData;
HoudiniInstancer[] instancers = myAssetOTL.gameObject.GetComponentsInChildren <HoudiniInstancer>();
foreach (HoudiniInstancer instancer in instancers)
{
HoudiniInstancerPersistentData persistent_data = null;
for (int ii = 0; ii < instancer_persistent_data.Count; ii++)
{
HoudiniInstancerPersistentData data = instancer_persistent_data[ii];
if (data.instancerName == instancer.name)
{
persistent_data = data;
break;
}
}
if (persistent_data == null)
{
Debug.LogError("Can't find persistent data for instancer: " + instancer.name);
continue;
}
Undo.RecordObject(persistent_data, "Houdini Instancer Change");
persistent_data.showInstancerGUI = HoudiniGUI.foldout(
persistent_data.instancerName, persistent_data.showInstancerGUI, true);
if (persistent_data.showInstancerGUI)
{
bool changed = false;
{
Vector3 dummy = new Vector3();
changed |= HoudiniGUI.floatField(
"RotationOffset", "Rotation Offset",
ref persistent_data.rotationalOffset, null, ref dummy);
changed |= HoudiniGUI.floatField(
"ScaleOffset", "Scale Offset", ref persistent_data.scaleOffset, null, ref dummy);
List <string> unique_names = persistent_data.uniqueNames;
for (int ii = 0; ii < unique_names.Count; ii++)
{
string instanced_name = unique_names[ii];
int base_index = persistent_data.baseIndex(ii);
for (int jj = 0; jj < persistent_data.numObjsToInstantiate[ii]; jj++)
{
Object obj = (Object)persistent_data.objsToInstantiate[base_index + jj];
GUILayout.BeginHorizontal();
string label = "";
if (jj == 0)
{
label = instanced_name;
}
changed |= HoudiniGUI.objectField(
"object_to_instantiate", label, ref obj, typeof(GameObject));
if (changed)
{
persistent_data.objsToInstantiate[base_index + jj] = (GameObject)obj;
}
if (GUILayout.Button("+"))
{
persistent_data.objsToInstantiate.Insert
(base_index + jj, null);
persistent_data.numObjsToInstantiate[ii]++;
persistent_data.recalculateVariations[ii] = true;
changed = true;
break;
}
if (GUILayout.Button("-"))
{
if (persistent_data.numObjsToInstantiate[ii] == 1)
{
persistent_data.objsToInstantiate[base_index] = null;
}
else
{
persistent_data.objsToInstantiate.RemoveAt(base_index + jj);
persistent_data.numObjsToInstantiate[ii]--;
}
persistent_data.recalculateVariations[ii] = true;
changed = true;
break;
}
GUILayout.EndHorizontal();
}
}
if (GUILayout.Button("Recalculate Variations"))
{
for (int ii = 0; ii < unique_names.Count; ii++)
{
persistent_data.recalculateVariations[ii] = true;
}
changed = true;
}
}
if (instancer.hasOverriddenInstances())
{
if (GUILayout.Button("UnPin All Instances"))
{
instancer.unPinAllInstances();
changed = true;
}
}
if (changed)
{
HoudiniProgressBar progress_bar = new HoudiniProgressBar();
instancer.instanceObjects(progress_bar);
progress_bar.clearProgressBar();
for (int ii = 0; ii < persistent_data.recalculateVariations.Count; ii++)
{
persistent_data.recalculateVariations[ii] = false;
}
}
}
EditorGUILayout.Separator();
}
}
private void generateCookingSettings()
{
// Enable Cooking Toggle
createToggleForProperty(
"enable_cooking", "Enable Cooking", "prEnableCooking",
ref myUndoInfo.enableCooking, null, !HoudiniHost.isEnableCookingDefault());
HoudiniGUI.separator();
// Cooking Triggers Downstream Cooks Toggle
createToggleForProperty(
"cooking_triggers_downstream_cooks", "Cooking Triggers Downstream Cooks",
"prCookingTriggersDownCooks", ref myUndoInfo.cookingTriggersDownCooks,
null, !HoudiniHost.isCookingTriggersDownCooksDefault(),
!myAsset.prEnableCooking, " (all cooking is disabled)");
// Playmode Per-Frame Cooking Toggle
createToggleForProperty(
"playmode_per_frame_cooking", "Playmode Per-Frame Cooking",
"prPlaymodePerFrameCooking", ref myUndoInfo.playmodePerFrameCooking,
null, !HoudiniHost.isPlaymodePerFrameCookingDefault(),
!myAsset.prEnableCooking, " (all cooking is disabled)");
HoudiniGUI.separator();
// Push Unity Transform To Houdini Engine Toggle
createToggleForProperty(
"push_unity_transform_to_houdini_engine", "Push Unity Transform To Houdini Engine",
"prPushUnityTransformToHoudini", ref myUndoInfo.pushUnityTransformToHoudini,
null, !HoudiniHost.isPushUnityTransformToHoudiniDefault());
// Transform Change Triggers Cooks Toggle
createToggleForProperty(
"transform_change_triggers_cooks", "Transform Change Triggers Cooks",
"prTransformChangeTriggersCooks", ref myUndoInfo.transformChangeTriggersCooks,
null, !HoudiniHost.isTransformChangeTriggersCooksDefault(),
!myAsset.prEnableCooking, " (all cooking is disabled)");
HoudiniGUI.separator();
// Import Templated Geos Toggle
createToggleForProperty(
"import_templated_geos", "Import Templated Geos", "prImportTemplatedGeos",
ref myUndoInfo.importTemplatedGeos, null, !HoudiniHost.isImportTemplatedGeosDefault(),
!myAsset.prEnableCooking, " (all cooking is disabled)");
HoudiniGUI.separator();
// Split Geos by Group Toggle
{
createToggleForProperty(
"split_geos_by_group_override", "Override Split Geos by Group", "prSplitGeosByGroupOverride",
ref myUndoInfo.splitGeosByGroupOverride, null);
createToggleForProperty(
"split_geos_by_group", "Split Geos by Group", "prSplitGeosByGroup",
ref myUndoInfo.splitGeosByGroup, () => EditorUtility.DisplayDialog(
"Rebuild Required",
"This change will take affect only after a full asset rebuild.",
"Ok"), false,
!myAsset.prSplitGeosByGroupOverride, " (check the override checkbox to enable)");
}
HoudiniGUI.separator();
// Omit Part Name Enumeration
createToggleForProperty(
"omit_part_name_enumeration", "Omit Part Name Enumeration",
"prOmitPartNameEnumeration", ref myUndoInfo.omitPartNameEnumeration,
null);
}
public override void OnInspectorGUI()
{
if (myGeoAttributeManager == null)
{
return;
}
bool is_editable = true;
// We can only build or do anything if we can link to our libraries.
#if !(UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
is_editable = false;
HoudiniGUI.help(HoudiniConstants.HAPI_UNSUPPORTED_PLATFORM_MSG, MessageType.Info);
#else
if (!is_editable)
{
HoudiniGUI.help("This mesh is not editable.", MessageType.Info);
}
#endif // !( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
bool gui_enable = GUI.enabled;
GUI.enabled = is_editable;
myAssetInput.prShowHoudiniControls
= HoudiniGUI.foldout("Houdini Controls", myAssetInput.prShowHoudiniControls, true);
if (myAssetInput.prShowHoudiniControls)
{
if (!myAssetInput.isPrefab())
{
if (GUILayout.Button("Rebuild"))
{
myAssetInput.buildAll();
}
if (GUILayout.Button("Recook"))
{
myAssetInput.buildClientSide();
}
}
}
// Draw Help Pane
myAssetInput.prShowHelp = HoudiniGUI.foldout("Asset Help", myAssetInput.prShowHelp, true);
if (myAssetInput.prShowHelp)
{
drawHelpBox(myHelpText);
}
///////////////////////////////////////////////////////////////////////
// Draw Asset Settings
// These don't affect the asset directly so they don't trigger rebuilds.
myAssetInput.prShowAssetSettings = HoudiniGUI.foldout("Asset Settings", myAssetInput.prShowAssetSettings, true);
if (myAssetInput.prShowAssetSettings)
{
// Enable Cooking Toggle
createToggleForProperty(
"enable_cooking", "Enable Cooking", "prEnableCooking",
ref myUndoInfo.enableCooking, null, !HoudiniHost.isEnableCookingDefault());
HoudiniGUI.separator();
// Cooking Triggers Downstream Cooks Toggle
createToggleForProperty(
"cooking_triggers_downstream_cooks", "Cooking Triggers Downstream Cooks",
"prCookingTriggersDownCooks", ref myUndoInfo.cookingTriggersDownCooks,
null, !HoudiniHost.isCookingTriggersDownCooksDefault(),
!myAssetInput.prEnableCooking, " (all cooking is disabled)");
HoudiniGUI.separator();
// Push Unity Transform To Houdini Engine Toggle
createToggleForProperty(
"push_unity_transform_to_houdini_engine", "Push Unity Transform To Houdini Engine",
"prPushUnityTransformToHoudini", ref myUndoInfo.pushUnityTransformToHoudini,
null, !HoudiniHost.isPushUnityTransformToHoudiniDefault());
// Transform Change Triggers Cooks Toggle
createToggleForProperty(
"transform_change_triggers_cooks", "Transform Change Triggers Cooks",
"prTransformChangeTriggersCooks", ref myUndoInfo.transformChangeTriggersCooks,
null, !HoudiniHost.isTransformChangeTriggersCooksDefault(),
!myAssetInput.prEnableCooking, " (all cooking is disabled)");
}
///////////////////////////////////////////////////////////////////////
// Draw Point Attributes
myAssetInput.prShowAttributesTable = HoudiniGUI.foldout("Point Attributes", myAssetInput.prShowAttributesTable, true);
if (myAssetInput.prShowAttributesTable)
{
// Draw Create Point Attributes Action Bar
{
string[] preset_labels = new string[] {
"Create Point Attribute:", "Custom", "Color", "UV", "Normal", "Bool", "Int", "Float", "String"
};
int[] preset_values = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
GUIStyle style = new GUIStyle(EditorStyles.popup);
style.fixedHeight = 18;
style.margin.bottom = 6;
int preset_selected = EditorGUILayout.IntPopup(
0, preset_labels, preset_values, style);
if (preset_selected == 1)
{
myGeoAttributeManager.createAttribute();
myAssetInput.prHasAttributeChanges = true;
}
else if (preset_selected > 1)
{
HoudiniGeoAttribute.Preset preset = (HoudiniGeoAttribute.Preset)(preset_selected - 2);
myGeoAttributeManager.createAttribute(preset);
myAssetInput.prHasAttributeChanges = true;
}
}
// Draw recook notice.
string help_msg = "There are uncommitted attribute changes. Press 'Recook' when ready.";
if (myAssetInput.prHasError)
{
help_msg += "\nError: " + myAssetInput.prErrorMsg;
}
if (myAssetInput.prHasAttributeChanges)
{
HoudiniGUI.help(help_msg, MessageType.Info);
}
else
{
HoudiniGUI.help("Ready", MessageType.Info);
}
HoudiniGUI.separator();
string[] type_labels = new string[] { "bool", "int", "float", "string" };
int[] type_values = new int[] { 0, 1, 2, 3 };
string[] tuple_labels = new string[] { "1", "2", "3", "4", "5" };
int[] tuple_values = new int[] { 1, 2, 3, 4, 5 };
// Draw table header.
{
EditorGUILayout.BeginHorizontal();
GUIStyle label_style = new GUIStyle(EditorStyles.label);
label_style.padding.right = -5;
label_style.margin.left = -5;
label_style.border.right = -10;
EditorGUILayout.LabelField("Name", GUILayout.MinWidth(100));
EditorGUILayout.LabelField("Type", GUILayout.Width(50));
EditorGUILayout.LabelField("Tuple", GUILayout.Width(50));
EditorGUILayout.LabelField("|", GUILayout.Width(8));
EditorGUILayout.LabelField("Min", GUILayout.Width(50));
EditorGUILayout.LabelField("Max", GUILayout.Width(50));
EditorGUILayout.LabelField("", GUILayout.Width(27));
EditorGUILayout.EndHorizontal();
}
for (int i = 0; i < myGeoAttributeManager.prAttributes.Count; ++i)
{
HoudiniGeoAttribute attrib = myGeoAttributeManager.prAttributes[i];
EditorGUILayout.BeginHorizontal();
// Attribute Name
string new_name = EditorGUILayout.TextField(attrib.prName, GUILayout.MinWidth(100));
if (new_name != attrib.prName)
{
attrib.prName = new_name;
myAssetInput.prHasAttributeChanges = true;
}
// Attribute Type
HoudiniGeoAttribute.Type new_attrib_type = (HoudiniGeoAttribute.Type)EditorGUILayout.IntPopup(
(int)attrib.prType, type_labels, type_values, GUILayout.Width(50));
if (new_attrib_type != attrib.prType)
{
attrib.prType = new_attrib_type;
myAssetInput.prHasAttributeChanges = true;
}
// Attribute Tuple Size
int new_tuple_size = EditorGUILayout.IntPopup(
attrib.prTupleSize, tuple_labels, tuple_values, GUILayout.Width(50));
if (new_tuple_size != attrib.prTupleSize)
{
attrib.prTupleSize = new_tuple_size;
myAssetInput.prHasAttributeChanges = true;
}
EditorGUILayout.LabelField("|", GUILayout.Width(8));
// Range
if (attrib.prType == HoudiniGeoAttribute.Type.STRING)
{
EditorGUILayout.LabelField("N/A", GUILayout.MinWidth(20));
}
else
{
if (attrib.prType == HoudiniGeoAttribute.Type.BOOL || attrib.prType == HoudiniGeoAttribute.Type.INT)
{
attrib.prIntMin =
EditorGUILayout.IntField("", attrib.prIntMin, GUILayout.Width(50));
}
else if (attrib.prType == HoudiniGeoAttribute.Type.FLOAT)
{
attrib.prFloatMin =
EditorGUILayout.FloatField("", attrib.prFloatMin, GUILayout.Width(50));
}
if (attrib.prType == HoudiniGeoAttribute.Type.BOOL || attrib.prType == HoudiniGeoAttribute.Type.INT)
{
attrib.prIntMax =
EditorGUILayout.IntField("", attrib.prIntMax, GUILayout.Width(50));
}
else if (attrib.prType == HoudiniGeoAttribute.Type.FLOAT)
{
attrib.prFloatMax =
EditorGUILayout.FloatField("", attrib.prFloatMax, GUILayout.Width(50));
}
}
EditorGUILayout.LabelField("|", GUILayout.Width(8));
GUIStyle label_style = new GUIStyle(EditorStyles.label);
label_style.fontStyle = FontStyle.Bold;
if (GUILayout.Button("X", label_style, GUILayout.Width(15), GUILayout.Height(15)))
{
myGeoAttributeManager.deleteAttribute(attrib.prName);
myAssetInput.prHasAttributeChanges = true;
}
EditorGUILayout.EndHorizontal();
}
{
EditorGUILayout.BeginHorizontal();
GUIStyle label_style = new GUIStyle(EditorStyles.label);
label_style.fontStyle = FontStyle.Normal;
label_style.alignment = TextAnchor.MiddleRight;
label_style.padding.left = 0;
label_style.margin.left = 0;
label_style.padding.right = 0;
label_style.margin.right = 0;
EditorGUILayout.LabelField("Delete Attribute", label_style, GUILayout.MinWidth(40));
label_style.fontStyle = FontStyle.Bold;
label_style.padding.left = 0;
label_style.margin.left = 6;
label_style.padding.right = 5;
label_style.margin.right = 5;
EditorGUILayout.LabelField("↲", label_style, GUILayout.Width(10));
EditorGUILayout.EndHorizontal();
}
} // Show Attributes Table
GUI.enabled = gui_enable;
}
private static void generateGeometrySettings()
{
// Paint Brush Rate
{
// Everything is opposite here because the higher the number the slower
// the paint rate and we want the user to think the higher the number
// the FASTER the rate - so we have to invert.
float value = HoudiniHost.prPaintBrushRate;
bool changed = HoudiniGUI.floatField(
"paint_brush_rate", "Paint Brush Rate",
ref value, 0.0f, 1.0f,
myUndoInfo,
ref myUndoInfo.paintBrushRate);
if (changed)
{
HoudiniHost.prPaintBrushRate = value;
HoudiniHost.repaint();
}
}
// Painting Mode Hot Key
{
KeyCode value = HoudiniHost.prPaintingModeHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"painting_mode_hot_key", "Painting Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.paintingModeHotKey);
if (changed)
{
HoudiniHost.prPaintingModeHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
// Painting Mode Colour
{
Color value = HoudiniHost.prPaintingModeColour;
bool changed = HoudiniGUI.colourField(
"painting_mode_colour", "Painting Mode",
ref value, myUndoInfo,
ref myUndoInfo.paintingModeColour);
if (changed)
{
HoudiniHost.prPaintingModeColour = value;
HoudiniHost.repaint();
}
}
// Painting Node Switch Hot Key
{
KeyCode value = HoudiniHost.prPaintingNodeSwitchHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"painting_node_switch_hot_key", "Node Switch Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.paintingNodeSwitchHotKey);
if (changed)
{
HoudiniHost.prPaintingNodeSwitchHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
// Painting Attribute Switch Hot Key
{
KeyCode value = HoudiniHost.prPaintingAttributeSwitchHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"painting_attribute_switch_hot_key", "Attr. Switch Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.paintingAttributeSwitchHotKey);
if (changed)
{
HoudiniHost.prPaintingAttributeSwitchHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
// Painting Value Change Hot Key
{
KeyCode value = HoudiniHost.prPaintingValueChangeHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"painting_value_change_hot_key", "Value Change Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.paintingValueChangeHotKey);
if (changed)
{
HoudiniHost.prPaintingValueChangeHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
// Painting Falloff Change Hot Key
{
KeyCode value = HoudiniHost.prPaintingFalloffChangeHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"painting_falloff_change_hot_key", "Falloff Change Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.paintingFalloffChangeHotKey);
if (changed)
{
HoudiniHost.prPaintingFalloffChangeHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Adding Points Mode Hot Key
{
KeyCode value = HoudiniHost.prAddingPointsModeHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"adding_points_mode_hot_key", "Adding Points Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.addingPointsModeHotKey);
if (changed)
{
HoudiniHost.prAddingPointsModeHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
// Adding Points Mode Colour
{
Color value = HoudiniHost.prAddingPointsModeColour;
bool changed = HoudiniGUI.colourField(
"adding_ponits_mode_colour", "Adding Points Mode",
ref value, myUndoInfo,
ref myUndoInfo.addingPointsModeColour);
if (changed)
{
HoudiniHost.prAddingPointsModeColour = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Editing Points Mode Hot Key
{
KeyCode value = HoudiniHost.prEditingPointsModeHotKey;
string[] labels =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.Select(v => v.ToString())
.ToArray();
KeyCode[] values =
System.Enum.GetValues(typeof(KeyCode))
.Cast <KeyCode>()
.ToArray();
bool changed = HoudiniGUI.dropdown(
"editing_points_mode_hot_key", "Editing Points Key",
ref value, labels, values, myUndoInfo,
ref myUndoInfo.editingPointsModeHotKey);
if (changed)
{
HoudiniHost.prEditingPointsModeHotKey = (KeyCode)value;
HoudiniHost.repaint();
}
}
// Editing Points Mode Colour
{
Color value = HoudiniHost.prEditingPointsModeColour;
bool changed = HoudiniGUI.colourField(
"editing_ponits_mode_colour", "Editing Points Mode",
ref value, myUndoInfo,
ref myUndoInfo.editingPointsModeColour);
if (changed)
{
HoudiniHost.prEditingPointsModeColour = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Wireframe Colour
{
Color value = HoudiniHost.prWireframeColour;
bool changed = HoudiniGUI.colourField(
"wireframe_colour", "Wireframe", ref value,
myUndoInfo, ref myUndoInfo.wireframeColour);
if (changed)
{
HoudiniHost.prWireframeColour = value;
HoudiniHost.repaint();
}
}
// Guide Wireframe Colour
{
Color value = HoudiniHost.prGuideWireframeColour;
bool changed = HoudiniGUI.colourField(
"guide_wireframe_colour", "Guide Wireframe",
ref value, myUndoInfo,
ref myUndoInfo.guideWireframeColour);
if (changed)
{
HoudiniHost.prGuideWireframeColour = value;
HoudiniHost.repaint();
}
}
// Unselectable Guide Wireframe Colour
{
Color value = HoudiniHost.prUnselectableGuideWireframeColour;
bool changed = HoudiniGUI.colourField(
"unselectable_guide_wireframe_colour",
"Unselectable Guide",
ref value, myUndoInfo,
ref myUndoInfo.unselectableGuideWireframeColour);
if (changed)
{
HoudiniHost.prUnselectableGuideWireframeColour = value;
HoudiniHost.repaint();
}
}
// Unselected Guide Wireframe Colour
{
Color value = HoudiniHost.prUnselectedGuideWireframeColour;
bool changed = HoudiniGUI.colourField(
"unselected_guide_wireframe_colour",
"Unselected Guide",
ref value, myUndoInfo,
ref myUndoInfo.unselectedGuideWireframeColour);
if (changed)
{
HoudiniHost.prUnselectedGuideWireframeColour = value;
HoudiniHost.repaint();
}
}
// Selected Guide Wireframe Colour
{
Color value = HoudiniHost.prSelectedGuideWireframeColour;
bool changed = HoudiniGUI.colourField(
"selected_guide_wireframe_colour",
"Selected Guide",
ref value, myUndoInfo,
ref myUndoInfo.selectedGuideWireframeColour);
if (changed)
{
HoudiniHost.prSelectedGuideWireframeColour = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Guide Point Size
{
float value = HoudiniHost.prGuidePointSize;
bool changed = HoudiniGUI.floatField(
"guide_point_size", "Guide Point Size",
ref value, 4.0f, 40.0f,
myUndoInfo,
ref myUndoInfo.guidePointSize);
if (changed)
{
HoudiniHost.prGuidePointSize = value;
HoudiniHost.repaint();
}
}
// Min. Distance For Point Selection
{
float value = HoudiniHost.prMinDistanceForPointSelection;
bool changed = HoudiniGUI.floatField(
"min_distance_for_point_selection",
"Min. Distance For Point Selection",
ref value, 1.0f, 20.0f,
myUndoInfo,
ref myUndoInfo.minDistanceForPointSelection);
if (changed)
{
HoudiniHost.prMinDistanceForPointSelection = value;
HoudiniHost.repaint();
}
}
// Guide Min. Distance For Mid Point Insertion
{
float value = HoudiniHost.prGuideMinDistanceForMidPointInsertion;
bool changed = HoudiniGUI.floatField(
"guide_min_distance_for_mid_point_insertion",
"Guide Min. Distance For Mid Point Insertion",
ref value, 1.0f, 20.0f,
myUndoInfo,
ref myUndoInfo.guideMinDistanceForMidPointInsertion);
if (changed)
{
HoudiniHost.prGuideMinDistanceForMidPointInsertion = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Create Groups from Bool Attribute
{
bool value = HoudiniHost.prCreateGroupsFromBoolAttributes;
bool changed = HoudiniGUI.toggle(
"create_groups_from_bool_attributes", "Create Groups from Bool Attributes",
ref value, myUndoInfo,
ref myUndoInfo.createGroupsFromBoolAttributes);
if (changed)
{
HoudiniHost.prCreateGroupsFromBoolAttributes = value;
HoudiniHost.repaint();
}
}
}
public override void OnInspectorGUI()
{
bool gui_enable = GUI.enabled;
// We can only build or do anything if we can link to our libraries.
#if !( HAPI_ENABLE_RUNTIME )
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 // !( HAPI_ENABLE_RUNTIME )
try
{
myDelayBuild = false;
myParmChanges = false;
///////////////////////////////////////////////////////////////////////
// Draw License/Logo Thingy
#if ( HAPI_ENABLE_RUNTIME )
drawLicenseLogo();
#endif
///////////////////////////////////////////////////////////////////////
// Draw Game Object Controls
if (HoudiniHost.isNodeValid(myAsset.prAssetId, myAsset.prNodeInfo.uniqueHoudiniNodeId) &&
(myAsset.prTransformInputCount > 0 || myAsset.prGeoInputCount > 0) &&
myAsset.prAssetType != HoudiniAsset.AssetType.TYPE_CURVE)
{
myAsset.prShowInputControls = HoudiniGUI.foldout("Inputs", myAsset.prShowInputControls, true);
if (myAsset.prShowInputControls)
{
if (myAsset.prNodeInfo.type == HAPI_NodeType.HAPI_NODETYPE_OBJ)
{
for (int ii = 0; ii < myAsset.prTransformInputCount; ++ii)
{
myParmChanges |= setTransformInput(ii);
}
}
if (myAsset.prUpStreamGeoObjects == null || myAsset.prUpStreamGeoAssets == null ||
myAsset.prUpStreamGeoObjects.Count <= 0 || myAsset.prUpStreamGeoAssets.Count <= 0)
{
myAsset.prGeoInputCount = 0;
}
for (int input_index = 0; input_index < myAsset.prGeoInputCount; ++input_index)
{
bool join_last = false;
bool no_label_toggle_last = true;
GameObject temp_obj = null;
HoudiniGUIParm geo_input = new HoudiniGUIParm(
"geo_input_" + input_index, myAsset.prGeoInputNames[input_index]);
Object obj = (Object)myAsset.prUpStreamGeoObjects[input_index];
myParmChanges |= HoudiniGUI.objectField(
ref geo_input, ref obj, typeof(GameObject), ref join_last, ref no_label_toggle_last, null, ref temp_obj);
HoudiniGUIParm geo_input_transform_type = new HoudiniGUIParm(
"geo_input_transform_type_" + input_index, "Keep world transform");
bool transform_type = myAsset.prGeoInputsTransformTypes[input_index] != 0;
bool TransformTypeUpdate = HoudiniGUI.toggle(ref geo_input_transform_type, ref transform_type);
bool need_build_client_side = false;
if (myParmChanges || !myAsset.isGeoInputValid(input_index))
{
if (!obj)
{
myAsset.removeGeoInput(input_index);
//myAsset.buildClientSide();
need_build_client_side = true;
}
else
{
GameObject new_obj = (GameObject)obj;
myAsset.prUpStreamGeoObjects[input_index] = new_obj;
// Select the asset component (if it exists).
HoudiniAsset asset = new_obj.GetComponent <HoudiniAsset>();
// If we're selecting a specific object to input than try and
// get the object id. Note that by getting the HAPI_ObjectControl
// component we also cover the geo and part controls because
// they all inherit from HAPI_ObjectControl. The user can therefore
// drag any gameObject under the asset into another asset's
// input and have it all work.
int object_index = 0;
HoudiniObjectControl obj_control = new_obj.GetComponent <HoudiniObjectControl>();
if (obj_control)
{
object_index = obj_control.prObjectId;
asset = obj_control.prAsset;
}
if (asset == null)
{
// Connecting a new game object
myAsset.addGeoAsGeoInput(new_obj, input_index);
myAsset.updateGeoInputTransformType(input_index, transform_type ? 1 : 0);
need_build_client_side = true;
//myAsset.buildClientSide();
}
else if (myAsset.prUpStreamGeoAssets[input_index] != asset)
{
// Connecting a new asset
if (myAsset == asset)
{
Debug.LogError("Can't connect an asset to itself!");
}
else
{
myAsset.addAssetAsGeoInput(asset, object_index, input_index);
myAsset.updateGeoInputTransformType(input_index, transform_type ? 1 : 0);
need_build_client_side = true;
//myAsset.buildClientSide();
}
}
}
}
if (TransformTypeUpdate)
{
myAsset.updateGeoInputTransformType(input_index, transform_type ? 1 : 0);
need_build_client_side = true;
}
if (need_build_client_side)
{
myAsset.buildClientSide();
}
} // for
} // if
} // if
// Draw Cook Log Pane
myAsset.prShowCookLog = HoudiniGUI.foldout("Asset Cook Log", myAsset.prShowCookLog, true);
if (myAsset.prShowCookLog)
{
drawCookLog();
}
}
catch (HoudiniError e)
{
Debug.LogError(e.ToString());
}
GUI.enabled = gui_enable;
}
private void generateMaterialSettings()
{
if (GUILayout.Button("Re-Render"))
{
HoudiniAssetUtility.reApplyMaterials(myAsset);
}
// Material Shader Type
{
HAPI_ShaderType value = myAsset.prMaterialShaderType;
bool is_bold = myParentPrefabAsset && myParentPrefabAsset.prMaterialShaderType != value;
string[] labels = { "OpenGL", "Houdini Mantra Renderer" };
HAPI_ShaderType[] values = { HAPI_ShaderType.HAPI_SHADER_OPENGL, HAPI_ShaderType.HAPI_SHADER_MANTRA };
bool changed = HoudiniGUI.dropdown(
"material_renderer", "Material Renderer", ref value,
is_bold, labels, values, myUndoInfo,
ref myUndoInfo.materialShaderType);
if (changed)
{
myAsset.prMaterialShaderType = (HAPI_ShaderType)value;
HoudiniAssetUtility.reApplyMaterials(myAsset);
}
}
// Render Resolution
{
bool delay_build = false;
int[] values = new int[2];
values[0] = (int)myAsset.prRenderResolution[0];
values[1] = (int)myAsset.prRenderResolution[1];
int[] undo_values = new int[2];
undo_values[0] = (int)myUndoInfo.renderResolution[0];
undo_values[1] = (int)myUndoInfo.renderResolution[1];
HoudiniGUIParm gui_parm = new HoudiniGUIParm("render_resolution", "Render Resolution", 2);
gui_parm.isBold =
myParentPrefabAsset &&
(int)myParentPrefabAsset.prRenderResolution[0] != values[0] &&
(int)myParentPrefabAsset.prRenderResolution[1] != values[1];
bool changed = HoudiniGUI.intField(
ref gui_parm, ref delay_build, ref values,
myUndoInfo, ref undo_values);
if (changed)
{
Vector2 new_resolution = new Vector2((float)values[0], (float)values[1]);
myAsset.prRenderResolution = new_resolution;
myUndoInfo.renderResolution = new_resolution;
}
}
// Show Vertex Colours
createToggleForProperty(
"show_only_vertex_colours", "Show Only Vertex Colors",
"prShowOnlyVertexColours", ref myUndoInfo.showOnlyVertexColours,
() => HoudiniAssetUtility.reApplyMaterials(myAsset));
// Generate Tangents
createToggleForProperty(
"generate_tangents", "Generate Tangents", "prGenerateTangents",
ref myUndoInfo.generateTangents,
() => myAssetOTL.build(
true, // reload_asset
false, // unload_asset_first
false, // serialization_recovery_only
true, // force_reconnect
false, // is_duplication
myAsset.prCookingTriggersDownCooks,
true // use_delay_for_progress_bar
), !HoudiniHost.isGenerateTangentsDefault());
}
private static void generateCookingSettings()
{
// Enable Cooking
{
bool value = HoudiniHost.prEnableCooking;
bool changed = HoudiniGUI.toggle(
"enable_cooking", "Enable Cooking", ref value,
myUndoInfo, ref myUndoInfo.enableCooking);
if (changed)
{
HoudiniHost.prEnableCooking = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Cooking Triggers Downstream Cooks
{
bool value = HoudiniHost.prCookingTriggersDownCooks;
bool changed = HoudiniGUI.toggle(
"cooking_triggers_downstream_cooks",
"Cooking Triggers Downstream Cooks",
ref value, myUndoInfo,
ref myUndoInfo.cookingTriggersDownCooks);
if (changed)
{
HoudiniHost.prCookingTriggersDownCooks = value;
HoudiniHost.repaint();
}
}
// Playmode Per-Frame Cooking
{
bool value = HoudiniHost.prPlaymodePerFrameCooking;
bool changed = HoudiniGUI.toggle(
"playmode_per_frame_cooking",
"Playmode Per-Frame Cooking",
ref value, myUndoInfo,
ref myUndoInfo.playmodePerFrameCooking);
if (changed)
{
HoudiniHost.prPlaymodePerFrameCooking = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Push Unity Transform To Houdini Engine
{
bool value = HoudiniHost.prPushUnityTransformToHoudini;
bool changed = HoudiniGUI.toggle(
"push_unity_transform_to_houdini",
"Push Unity Transform to Houdini Engine",
ref value, myUndoInfo,
ref myUndoInfo.pushUnityTransformToHoudini);
if (changed)
{
HoudiniHost.prPushUnityTransformToHoudini = value;
HoudiniHost.repaint();
}
}
// Transform Change Triggers Cooks
{
bool value = HoudiniHost.prTransformChangeTriggersCooks;
bool changed = HoudiniGUI.toggle(
"transform_change_triggers_cooks",
"Transform Change Triggers Cooks",
ref value, myUndoInfo,
ref myUndoInfo.transformChangeTriggersCooks);
if (changed)
{
HoudiniHost.prTransformChangeTriggersCooks = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Import Templated Geos
{
bool value = HoudiniHost.prImportTemplatedGeos;
bool changed = HoudiniGUI.toggle(
"import_templated_geos",
"Import Templated Geos",
ref value, myUndoInfo,
ref myUndoInfo.importTemplatedGeos);
if (changed)
{
HoudiniHost.prImportTemplatedGeos = value;
HoudiniHost.repaint();
}
}
HoudiniGUI.separator();
// Split Geos by Group
{
bool value = HoudiniHost.prSplitGeosByGroup;
bool changed = HoudiniGUI.toggle(
"split_geos_by_group",
"Split Geos by Group",
ref value, myUndoInfo,
ref myUndoInfo.splitGeosByGroup);
if (changed)
{
HoudiniHost.prSplitGeosByGroup = value;
HoudiniHost.repaint();
EditorUtility.DisplayDialog(
"Rebuild Required",
"This change will take affect only after a full asset rebuild.",
"Ok");
}
}
// Split Points by Vertex Attributes
{
bool value = HoudiniHost.prSplitPointsByVertexAttributes;
bool changed = HoudiniGUI.toggle(
"split_points_by_vertex_attributes",
"Split Points by Vertex Attributes",
ref value, myUndoInfo,
ref myUndoInfo.splitGeosByGroup);
if (changed)
{
HoudiniHost.prSplitPointsByVertexAttributes = value;
HoudiniHost.repaint();
EditorUtility.DisplayDialog(
"Rebuild Required",
"This change will take affect only after a full asset rebuild.",
"Ok");
}
}
}
public override void OnInspectorGUI()
{
bool gui_enable = GUI.enabled;
// We can only build or do anything if we can link to our libraries.
#if !( HAPI_ENABLE_RUNTIME )
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 // !( HAPI_ENABLE_RUNTIME )
try
{
myDelayBuild = false;
myParmChanges = false;
///////////////////////////////////////////////////////////////////////
// Draw License/Logo Thingy
#if ( HAPI_ENABLE_RUNTIME )
drawLicenseLogo();
#endif
///////////////////////////////////////////////////////////////////////
// Draw Game Object Controls
/*if ( HoudiniHost.isNodeValid( myAsset.prAssetId, myAsset.prNodeInfo.uniqueHoudiniNodeId ) &&
* ( myAsset.prTransformInputCount > 0 || myAsset.prGeoInputCount > 0 ) &&
* myAsset.prAssetSubType != HAPI_AssetSubType.HAPI_ASSETSUBTYPE_CURVE )
* {
* myAsset.prShowInputControls = HoudiniGUI.foldout( "Inputs", myAsset.prShowInputControls, true );
*
* if ( myAsset.prShowInputControls )
* {
* if ( myAsset.prHAPIAssetType == HAPI_AssetType.HAPI_ASSETTYPE_OBJ )
* for ( int ii = 0; ii < myAsset.prTransformInputCount; ++ii )
* myParmChanges |= setTransformInput( ii );
*
* if ( myAsset.prUpStreamGeoObjects == null || myAsset.prUpStreamGeoAssets == null ||
* myAsset.prUpStreamGeoObjects.Count <= 0 || myAsset.prUpStreamGeoAssets.Count <= 0 )
* myAsset.prGeoInputCount = 0;
*
* for ( int input_index = 0; input_index < myAsset.prGeoInputCount; ++input_index )
* {
* bool join_last = false;
* bool no_label_toggle_last = true;
*
* HoudiniGUIParm geo_input = new HoudiniGUIParm(
* "geo_input_" + input_index, myAsset.prGeoInputNames[ input_index ] );
* Object obj = (Object) myAsset.prUpStreamGeoObjects[ input_index ];
* myParmChanges |= HoudiniGUI.objectField(
* ref geo_input, ref obj, typeof( GameObject ), ref join_last, ref no_label_toggle_last );
*
* if ( myParmChanges || !myAsset.isGeoInputValid( input_index ) )
* {
* if ( !obj )
* {
* myAsset.removeGeoInput( input_index );
* myAsset.buildClientSide();
* }
* else
* {
* GameObject new_obj = (GameObject) obj;
* myAsset.prUpStreamGeoObjects[ input_index ] = new_obj;
*
* // Select the asset component (if it exists).
* HoudiniAsset asset = new_obj.GetComponent< HoudiniAsset >();
*
* // If we're selecting a specific object to input than try and
* // get the object id. Note that by getting the HAPI_ObjectControl
* // component we also cover the geo and part controls because
* // they all inherit from HAPI_ObjectControl. The user can therefore
* // drag any gameObject under the asset into another asset's
* // input and have it all work.
* int object_index = 0;
* HoudiniObjectControl obj_control = new_obj.GetComponent< HoudiniObjectControl >();
* if ( obj_control )
* {
* object_index = obj_control.prObjectId;
* asset = obj_control.prAsset;
* }
*
* if ( asset == null )
* {
* myAsset.addGeoAsGeoInput( new_obj, input_index );
* myAsset.buildClientSide();
* }
* else if ( myAsset.prUpStreamGeoAssets[ input_index ] != asset )
* {
* if ( myAsset == asset )
* Debug.LogError( "Can't connect an asset to itself!" );
* else
* {
* myAsset.addAssetAsGeoInput( asset, object_index, input_index );
* myAsset.buildClientSide();
* }
* }
* }
* }
* } // for
* } // if
* } // if
*/
// Draw Cook Log Pane
myAsset.prShowCookLog = HoudiniGUI.foldout("Asset Cook Log", myAsset.prShowCookLog, true);
if (myAsset.prShowCookLog)
{
drawCookLog();
}
}
catch (HoudiniError e)
{
Debug.LogError(e.ToString());
}
GUI.enabled = gui_enable;
}
public override void OnInspectorGUI()
{
if (myAssetMerger == null)
{
return;
}
bool is_editable = true;
// We can only build or do anything if we can link to our libraries.
#if !( HAPI_ENABLE_RUNTIME )
is_editable = false;
HoudiniGUI.help(HoudiniConstants.HAPI_UNSUPPORTED_PLATFORM_MSG, MessageType.Info);
#else
if (!is_editable)
{
HoudiniGUI.help("This mesh is not editable.", MessageType.Info);
}
#endif // !( HAPI_ENABLE_RUNTIME )
bool gui_enable = GUI.enabled;
GUI.enabled = is_editable;
myAssetMerger.prShowInputSelection =
HoudiniGUI.foldout("Houdini Input Selection", myAssetMerger.prShowInputSelection, true);
if (myAssetMerger.prShowInputSelection)
{
bool changed = false;
Object input_object = myAssetMerger.prInputObject as Object;
GameObject temp_obj = null;
HoudiniGUI.objectField(
"input_object", "Input Object", ref input_object,
typeof(GameObject), null, ref temp_obj);
myAssetMerger.prInputObject = input_object as GameObject;
bool input_layer_enable = myAssetMerger.prUseLayerMask;
HoudiniGUIParm input_layer_enable_parm = new HoudiniGUIParm("input_layer_enable", "");
input_layer_enable_parm.joinNext = true;
input_layer_enable_parm.labelNone = true;
changed = HoudiniGUI.toggle(ref input_layer_enable_parm, ref input_layer_enable);
if (changed)
{
myAssetMerger.prUseLayerMask = input_layer_enable;
}
LayerMask input_layer = myAssetMerger.prLayerMask;
HoudiniGUIParm input_layer_parm = new HoudiniGUIParm("input_layer", "Layer");
input_layer_parm.disabled = !input_layer_enable;
bool join_last = true;
bool no_label_toggle_last = true;
changed = HoudiniGUI.layerField(ref input_layer_parm, ref input_layer, ref join_last, ref no_label_toggle_last);
if (changed)
{
myAssetMerger.prLayerMask = input_layer;
}
bool input_tag_enable = myAssetMerger.prUseTag;
HoudiniGUIParm input_tag_enable_parm = new HoudiniGUIParm("input_tag_enable", "");
input_tag_enable_parm.joinNext = true;
input_tag_enable_parm.labelNone = true;
changed = HoudiniGUI.toggle(ref input_layer_enable_parm, ref input_tag_enable);
if (changed)
{
myAssetMerger.prUseTag = input_tag_enable;
}
string input_tag = myAssetMerger.prTag;
HoudiniGUIParm input_tag_parm = new HoudiniGUIParm("input_tag", "Tag");
input_tag_parm.disabled = !input_tag_enable;
join_last = true;
no_label_toggle_last = true;
changed = HoudiniGUI.tagField(ref input_tag_parm, ref input_tag, ref join_last, ref no_label_toggle_last);
if (changed)
{
myAssetMerger.prTag = input_tag;
}
}
myAssetMerger.prShowHoudiniControls =
HoudiniGUI.foldout("Houdini Controls", myAssetMerger.prShowHoudiniControls, true);
if (myAssetMerger.prShowHoudiniControls)
{
if (GUILayout.Button("Recook"))
{
myAssetMerger.buildClientSide();
}
}
GUI.enabled = gui_enable;
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
bool gui_enable = GUI.enabled;
// We can only build or do anything if we can link to our libraries.
#if !( HAPI_ENABLE_RUNTIME )
GUI.enabled = false;
#else
if (!HoudiniHost.isInstallationOk())
{
GUI.enabled = false;
}
#endif // !( HAPI_ENABLE_RUNTIME )
///////////////////////////////////////////////////////////////////////
// Draw Game Object Controls
myAsset.prShowHoudiniControls
= HoudiniGUI.foldout("Houdini Controls", myAsset.prShowHoudiniControls, true);
if (myAsset.prShowHoudiniControls)
{
if (GUILayout.Button("Rebuild"))
{
myGeoAttributeManagerGUI = null;
myAsset.buildAll();
}
if (GUILayout.Button("Recook"))
{
myAsset.buildClientSide();
}
if (GUILayout.Button("Bake"))
{
myAsset.bakeAsset();
}
}
// Draw Help Pane
myAsset.prShowHelp = HoudiniGUI.foldout("Asset Help", myAsset.prShowHelp, true);
if (myAsset.prShowHelp)
{
drawHelpBox(myAsset.prAssetHelp);
}
///////////////////////////////////////////////////////////////////////
// Draw Asset Settings
// These don't affect the asset directly so they don't trigger rebuilds.
myAsset.prShowAssetSettings = HoudiniGUI.foldout("Asset Settings", myAsset.prShowAssetSettings, true);
if (myAsset.prShowAssetSettings)
{
generateAssetSettings();
}
///////////////////////////////////////////////////////////////////////
// Draw Baking Controls
myAsset.prShowBakeOptions = HoudiniGUI.foldout("Bake Animations", myAssetOTL.prShowBakeOptions, true);
if (myAsset.prShowBakeOptions)
{
generateAssetBakeControls();
}
GUI.enabled = gui_enable;
}
protected bool generateAssetControls()
{
if (myParms.prParms == null)
{
return(false);
}
bool changed = false;
int current_index = 0;
HAPI_ParmInfo[] parms = myParms.prParms;
HAPI_ParmInfoStrings[] parm_strings = myParms.prParmInfoStrings;
bool join_last = false;
bool no_label_toggle_last = false;
int folder_list_count = 0;
// These stacks maintain the current folder depth, parent id, and how many more child
// parameters are still contained in the current folder.
Stack <int> parent_id_stack = new Stack <int>();
Stack <int> parent_count_stack = new Stack <int>();
int instance_length = -1;
// Loop through all the parameters.
while (current_index < myParms.prParmCount)
{
int current_parent_id = HoudiniConstants.HAPI_INVALID_PARM_ID; // The root has parent id -1.
// If we're not at the root (empty parent stack), get the current parent id and parent
// count from the stack as well as decrement the parent count as we're about to parse
// another parameter.
if (parent_id_stack.Count != 0)
{
current_parent_id = parent_id_stack.Peek();
// Get the leftover parameter count of the current folder.
int current_parent_count = parent_count_stack.Peek();
// The only reason current_parent_count would be 0 at this point is if we start off
// with an empty folder. Pop it and move on, but do not increment the current_index!
if (current_parent_count <= 0)
{
parent_id_stack.Pop();
parent_count_stack.Pop();
continue;
}
// If the current parameter, whatever it may be, does not belong to the current active
// parent then skip it. This check has to be done here because we do not want to
// increment the top of the parent_count_stack as if we included a parameter in the
// current folder.
if (parms[current_index].parentId != current_parent_id)
{
current_index++;
continue;
}
// Decrement the leftover parameter count.
current_parent_count--;
// If we've reached the last parameter in the current folder we need to pop the parent
// stacks (we're done with the current folder). Otherwise, update the top of the
// parent_count_stack.
if (current_parent_count <= 0)
{
parent_id_stack.Pop();
parent_count_stack.Pop();
}
else
{
parent_count_stack.Pop();
parent_count_stack.Push(current_parent_count);
}
}
else if (parms[current_index].parentId != current_parent_id)
{
// If the current parameter does not belong to the current active parent then skip it.
current_index++;
continue;
}
if (parms[current_index].type == HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST)
{
changed |= generateAssetControl(current_index, ref join_last, ref no_label_toggle_last);
//int instance_count = myParms.prParmIntValues[ parms[ current_index ].intValuesIndex ];
int instance_count = parms[current_index].instanceCount;
instance_length = parms[current_index].instanceLength;
if (instance_length > 0)
{
for (int i = 0; i < instance_count; i++)
{
parent_id_stack.Push(parms[current_index].id);
parent_count_stack.Push(1);
}
}
current_index++;
}
else if (parms[current_index].type == HAPI_ParmType.HAPI_PARMTYPE_FOLDERLIST)
{
// The current parameter is a folder list which means the next parms[ current_index ].size
// parameters will be folders belonging to this folder list. Push to the stack a new
// folder depth, ready to eat the next few parameters belonging to the folder list's
// selected folder.
bool folder_list_invisible = parms[current_index].invisible;
int folder_count = parms[current_index].size;
int first_folder_index = current_index + 1;
int last_folder_index = current_index + folder_count;
// Generate the list of folders which will be passed to the GUILayout.Toolbar() method.
List <int> tab_ids = new List <int>();
List <string> tab_labels = new List <string>();
List <int> tab_sizes = new List <int>();
bool has_visible_folders = false;
for (current_index = first_folder_index; current_index <= last_folder_index; ++current_index)
{
if (parms[current_index].type != HAPI_ParmType.HAPI_PARMTYPE_FOLDER)
{
Debug.LogError("We should be iterating through folders only here!"
+ "\nCurrent Index: " + current_index + ", folder_count: " + folder_count);
}
// Don't add this folder if it's invisible.
if (parms[current_index].invisible || folder_list_invisible)
{
continue;
}
else
{
has_visible_folders = true;
}
tab_ids.Add(parms[current_index].id);
tab_labels.Add(parm_strings[current_index].label);
tab_sizes.Add(parms[current_index].size);
}
current_index--; // We decrement the current_index as we incremented one too many in the for loop.
// If there are no folders visible in this folder list, don't even append the folder stacks.
if (has_visible_folders)
{
folder_list_count++;
// If myObjectControl.myFolderListSelections is smaller than our current depth it means this
// is the first GUI generation for this asset (no previous folder selection data) so
// increase the size of the selection arrays to accomodate the new depth.
if (myParms.prFolderListSelections.Count <= folder_list_count)
{
myParms.prFolderListSelections.Add(0);
myParms.prFolderListSelectionIds.Add(HoudiniConstants.HAPI_INVALID_PARM_ID);
}
int selected_folder = myParms.prFolderListSelections[folder_list_count];
selected_folder = Mathf.Clamp(selected_folder, 0, tab_labels.Count - 1);
selected_folder = GUILayout.Toolbar(selected_folder, tab_labels.ToArray());
myParms.prFolderListSelections[folder_list_count] = selected_folder;
// Push only the selected folder info to the parent stacks since for this depth and this folder
// list only the parameters of the selected folder need to be generated.
parent_id_stack.Push(tab_ids[selected_folder]);
parent_count_stack.Push(tab_sizes[selected_folder]);
}
current_index++;
}
else if (parms[current_index].isChildOfMultiParm)
{
GUILayout.BeginHorizontal();
// Create the add / remove buttons
GUILayout.BeginHorizontal();
if (GUILayout.Button("X"))
{
myParms.removeMultiparmInstance(parms[current_index]);
changed = true;
}
if (GUILayout.Button("+"))
{
myParms.insertMultiparmInstance(parms[current_index]);
changed = true;
}
GUILayout.EndHorizontal();
// Create the parms within the multiparm instance
GUILayout.BeginVertical();
for (int i = 0; i < instance_length; i++)
{
changed |= generateAssetControl(current_index, ref join_last, ref no_label_toggle_last);
current_index++;
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (instance_length > 1)
{
HoudiniGUI.separator();
}
}
else
{
// The current parameter is a simple parameter so just draw it.
if (parms[current_index].type == HAPI_ParmType.HAPI_PARMTYPE_FOLDER)
{
Debug.LogError("All folders should have been parsed in the folder list if clause!");
}
changed |= generateAssetControl(current_index, ref join_last, ref no_label_toggle_last);
current_index++;
}
}
if (myLastFocusedControl != GUI.GetNameOfFocusedControl())
{
//Debug.Log( "Changed focus from " + myLastFocusedControl + " to " + GUI.GetNameOfFocusedControl() );
// We changed focus. Signal a build
myLastFocusedControl = GUI.GetNameOfFocusedControl();
myFocusChanged = true;
myDelayBuild = false;
}
return(changed);
}
private static void generateAdvancedSettings()
{
if (!myEnableAdvancedSettings)
{
if (HoudiniGUI.button(
"allow_advanced_settings", "Allow Editing of Advanced Settings"))
{
if (EditorUtility.DisplayDialog(
"Careful!",
"Changing these settings can cause the Houdini Engine plugin to stop working. " +
"Are you sure you want to edit them?",
"Yes", "No"))
{
myEnableAdvancedSettings = true;
}
}
}
else
{
if (HoudiniGUI.button(
"disallow_advanced_settings", "Disallow Editing of Advanced Settings"))
{
myEnableAdvancedSettings = false;
}
}
HoudiniGUI.separator();
bool gui_enabled = GUI.enabled;
GUI.enabled = myEnableAdvancedSettings;
// Collision Group Name
{
string value = HoudiniHost.prCollisionGroupName;
bool changed = HoudiniGUI.stringField(
"collision_group_name", "Colli. Grp.", ref value,
myUndoInfo, ref myUndoInfo.collisionGroupName);
if (changed)
{
HoudiniHost.prCollisionGroupName = value;
}
}
// Rendered Collision Group Name
{
string value = HoudiniHost.prRenderedCollisionGroupName;
bool changed = HoudiniGUI.stringField(
"rendered_collision_group_name",
"Rendered Colli. Grp.", ref value, myUndoInfo,
ref myUndoInfo.renderedCollisionGroupName);
if (changed)
{
HoudiniHost.prRenderedCollisionGroupName = value;
}
}
HoudiniGUI.separator();
// Unity Material Attrib Name
{
string value = HoudiniHost.prUnityMaterialAttribName;
bool changed = HoudiniGUI.stringField(
"unity_material_attrib_name",
"Unity Mat. Attrib.",
ref value, myUndoInfo,
ref myUndoInfo.unityMaterialAttribName);
if (changed)
{
HoudiniHost.prUnityMaterialAttribName = value;
}
}
// Unity Sub Material Name Attrib Name
{
string value = HoudiniHost.prUnitySubMaterialNameAttribName;
bool changed = HoudiniGUI.stringField(
"unity_sub_material_name_attrib_name",
"Unity SubMat. Name Attrib.",
ref value, myUndoInfo,
ref myUndoInfo.unitySubMaterialNameAttribName);
if (changed)
{
HoudiniHost.prUnitySubMaterialNameAttribName = value;
}
}
// Unity Sub Material Index Attrib Name
{
string value = HoudiniHost.prUnitySubMaterialIndexAttribName;
bool changed = HoudiniGUI.stringField(
"unity_sub_material_index_attrib_name",
"Unity SubMat. Index Attrib.",
ref value, myUndoInfo,
ref myUndoInfo.unitySubMaterialIndexAttribName);
if (changed)
{
HoudiniHost.prUnitySubMaterialIndexAttribName = value;
}
}
HoudiniGUI.separator();
// Unity Tag Attrib Name
{
string value = HoudiniHost.prUnityTagAttribName;
bool changed = HoudiniGUI.stringField(
"unity_tag_attrib_name", "Unity Tag Attrib.",
ref value, myUndoInfo,
ref myUndoInfo.unityTagAttribName);
if (changed)
{
HoudiniHost.prUnityTagAttribName = value;
}
}
GUI.enabled = gui_enabled;
}
public void OnGUI()
{
bool gui_enable = GUI.enabled;
#if !( HAPI_ENABLE_RUNTIME )
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 // !( HAPI_ENABLE_RUNTIME )
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))
{
HoudiniGUIUtility.saveHoudiniScene(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 ( HAPI_ENABLE_RUNTIME )
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 // ( HAPI_ENABLE_RUNTIME )
GUILayout.EndScrollView();
GUI.enabled = gui_enable;
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
bool gui_enable = GUI.enabled;
// We can only build or do anything if we can link to our libraries.
#if !(UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || (UNITY_METRO && UNITY_EDITOR))
GUI.enabled = false;
#else
if (!HoudiniHost.isInstallationOk())
{
GUI.enabled = false;
}
#endif // !( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) )
if (myAssetOTL.isPrefabInstance())
{
myParentPrefabAsset = myAsset.getParentPrefabAsset();
}
///////////////////////////////////////////////////////////////////////
// Draw Game Object Controls
myAsset.prShowHoudiniControls
= HoudiniGUI.foldout("Houdini Controls", myAsset.prShowHoudiniControls, true);
if (myAsset.prShowHoudiniControls)
{
if (!myAsset.isPrefab())
{
if (GUILayout.Button("Rebuild"))
{
myAsset.buildAll();
}
if (GUILayout.Button("Recook"))
{
myAsset.buildClientSide();
}
if (GUILayout.Button("Bake"))
{
myAsset.bakeAsset();
}
}
}
// Draw Help Pane
myAsset.prShowHelp = HoudiniGUI.foldout("Asset Help", myAsset.prShowHelp, true);
if (myAsset.prShowHelp)
{
drawHelpBox(myAsset.prAssetHelp);
}
///////////////////////////////////////////////////////////////////////
// Draw Asset Settings
// These don't affect the asset directly so they don't trigger rebuilds.
myAsset.prShowAssetSettings = HoudiniGUI.foldout("Asset Settings", myAsset.prShowAssetSettings, true);
if (myAsset.prShowAssetSettings)
{
generateAssetSettings();
}
///////////////////////////////////////////////////////////////////////
// Draw Baking Controls
if (!myAsset.isPrefab())
{
myAsset.prShowBakeOptions = HoudiniGUI.foldout("Bake Animations", myAssetOTL.prShowBakeOptions, true);
if (myAsset.prShowBakeOptions)
{
generateAssetBakeControls();
}
}
///////////////////////////////////////////////////////////////////////
// Draw Paint Tools
#if !HAPI_PAINT_SUPPORT
if (!myAsset.isPrefab())
{
myAsset.prShowPaintTools = HoudiniGUI.foldout("Paint Tools", myAssetOTL.prShowPaintTools, true);
if (myAsset.prShowPaintTools)
{
generatePaintToolGUI();
}
}
#endif // !HAPI_PAINT_SUPPORT
GUI.enabled = gui_enable;
}
