// Set into dictionary to later be set into the host public void setParmStrings(HAPI_ParmInfo parm, string[] strings) { for (int i = 0; i < parm.size; ++i) { myParmStringValues[parm.stringValuesIndex + i] = strings[i]; } }
public void initDefaultParameters() { // Set curve defaults. // TODO: Make the defaults editable. // TODO: Make generic update parm value functions. try { HAPI_ParmInfo primitive_type_parm = prParms.findParm("type"); HAPI_ParmInfo method_parm = prParms.findParm("method"); int primitive_type_parm_default = HoudiniHost.prCurvePrimitiveTypeDefault; int method_parm_default = HoudiniHost.prCurveMethodDefault; int primitive_type_parm_int_values = primitive_type_parm.intValuesIndex; int method_parm_int_values = method_parm.intValuesIndex; prParms.prParmIntValues[primitive_type_parm_int_values] = primitive_type_parm_default; prParms.prParmIntValues[method_parm_int_values] = method_parm_default; int[] temp_int_values = new int[1]; temp_int_values[0] = primitive_type_parm_default; HoudiniHost.setParmIntValues(prControl.prNodeId, temp_int_values, primitive_type_parm.intValuesIndex, 1); temp_int_values[0] = method_parm_default; HoudiniHost.setParmIntValues(prControl.prNodeId, temp_int_values, method_parm.intValuesIndex, 1); HoudiniHost.cookAsset(prControl.prAsset.prAssetId, prControl.prAsset.prSplitGeosByGroup); } catch {} }
public void cacheStringsFromHost() { myParmsUndoInfo.parmStringValues = new string[prParmStringValueCount]; // For each string parameter, cache the string from the host for (int i = 0; i < prParms.Length; ++i) { HAPI_ParmInfo parm = prParms[i]; // Cache the strings in the parm info struct. myParmInfoStrings[i].cacheStrings(parm); if (parm.isString()) { string[] strings = new string[parm.size]; for (int p = 0; p < parm.size; ++p) { int values_index = parm.stringValuesIndex + p; string string_value = HoudiniHost.getString(prParmStringHandles[values_index]); strings[p] = string_value; myParmsUndoInfo.parmStringValues[values_index] = string_value; } setParmStrings(parm, strings); } } // Cache the choice list strings. for (int i = 0; i < myParmChoiceLists.Length; ++i) { myParmChoiceInfoStrings[i].cacheStrings(myParmChoiceLists[i]); } }
public void setChangedParameterIntoHost(int id) { if (prControl == null) { return; } if (prControl.prAsset == null) { return; } if (id == -1) { return; } HAPI_ParmInfo parm = findParm(id); if ((HAPI_ParmType)parm.type == HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST) { int[] values = new int[1]; HoudiniHost.getParmIntValues(prControl.prNodeId, values, parm.intValuesIndex, 1); int difference = prParmIntValues[parm.intValuesIndex] - values[0]; if (difference > 0) { appendMultiparmInstances(parm, difference); } else if (difference < 0) { removeMultiparmInstances(parm, -difference); } getParameterValues(); } else if (parm.isNode()) { setChangedNodeParameterIntoHost(id); } else if (parm.isFloat()) { float[] values = new float[parm.size]; Array.Copy(prParmFloatValues, parm.floatValuesIndex, values, 0, parm.size); HoudiniHost.setParmFloatValues(prControl.prNodeId, values, parm.floatValuesIndex, parm.size); } else if (parm.isInt() && (HAPI_ParmType)parm.type != HAPI_ParmType.HAPI_PARMTYPE_MULTIPARMLIST) { int[] values = new int[parm.size]; Array.Copy(prParmIntValues, parm.intValuesIndex, values, 0, parm.size); HoudiniHost.setParmIntValues(prControl.prNodeId, values, parm.intValuesIndex, parm.size); } else if (parm.isString()) { string[] strings = getParmStrings(parm); for (int p = 0; p < parm.size; ++p) { HoudiniHost.setParmStringValue(prControl.prNodeId, strings[p], parm.id, p); } } }
public void cacheStrings(HAPI_ParmInfo parm_info) { typeInfo = parm_info.typeInfo; name = parm_info.name; label = parm_info.label; templateName = parm_info.templateName; help = parm_info.help; }
// This will retrieve the cached copy of the string public string[] getParmStrings(HAPI_ParmInfo parm) { string[] strings = new string[parm.size]; for (int i = 0; i < parm.size; ++i) { strings[i] = myParmStringValues[parm.stringValuesIndex + i]; } return(strings); }
public float getParmFloatValue(string name, int index) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); if (parm_info.isFloat()) { return(myAssetParms.prParmFloatValues[parm_info.floatValuesIndex + index]); } throw new HoudiniErrorInvalidArgument(name + " is not a float!"); }
public string getParmStringValue(string name, int index) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); if (parm_info.isString()) { return(myAssetParms.getParmStrings(parm_info)[index]); } throw new HoudiniErrorInvalidArgument(name + " is not a string!"); }
public void setParmStringValue(string name, int index, string value) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); if (!parm_info.isString()) { throw new HoudiniErrorInvalidArgument(name + " is not a string!"); } HoudiniHost.setParmStringValue(myAsset.prNodeId, value, parm_info.id, index); myAsset.buildClientSide(); }
public void setParmFloatValue(string name, int index, float value) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); if (!parm_info.isFloat()) { throw new HoudiniErrorInvalidArgument(name + " is not a float!"); } int values_index = parm_info.floatValuesIndex + index; float[] float_value = { value }; HoudiniHost.setParmFloatValues(myAsset.prNodeId, float_value, values_index, 1); myAsset.buildClientSide(); }
public void reset() { // Please keep these in the same order and grouping as their declarations at the top. // Assets ------------------------------------------------------------------------------------------------------- prControl = null; // Parameters ----------------------------------------------------------------------------------------------- prEditable = true; prParmCount = 0; prParmIntValueCount = 0; prParmFloatValueCount = 0; prParmStringValueCount = 0; prParmChoiceCount = 0; prParms = new HAPI_ParmInfo[0]; prParmIntValues = new int[0]; prParmFloatValues = new float[0]; prParmStringHandles = new HAPI_StringHandle[0]; prParmChoiceLists = new HAPI_ParmChoiceInfo[0]; myParmInfoStrings = new HAPI_ParmInfoStrings[0]; myParmChoiceInfoStrings = new HAPI_ParmChoiceInfoStrings[0]; myParmStringValues = new string[0]; prLastChangedParmId = -1; myParmsUndoInfo = null; prFolderListSelections = new List <int>(); prFolderListSelectionIds = new List <int>(); prFolderListSelections.Add(0); prFolderListSelectionIds.Add(-1); // Control ------------------------------------------------------------------------------------------------- myPostSerialization = true; myValuesEqualToHoudini = false; }
public void appendMultiparmInstances(HAPI_ParmInfo multiparm, int num_instances) { if (prControl == null) { return; } if (prControl.prAsset == null) { return; } int insert_position = multiparm.instanceCount + multiparm.instanceStartOffset; for (int i = 0; i < num_instances; ++i) { HoudiniHost.insertMultiparmInstance( prControl.prNodeId, multiparm.id, // The multiparm list insert_position + i); } }
public void removeMultiparmInstances(HAPI_ParmInfo multiparm, int num_instances) { if (prControl == null) { return; } if (prControl.prAsset == null) { return; } int first_removed_instance = multiparm.instanceCount - num_instances + multiparm.instanceStartOffset; for (int i = 0; i < num_instances; ++i) { HoudiniHost.removeMultiparmInstance( prControl.prNodeId, multiparm.id, // The multiparm list first_removed_instance); } }
public void setParmIntValue(string name, int index, int value) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); if (!parm_info.isInt()) { throw new HoudiniErrorInvalidArgument(name + " is not an int!"); } int values_index = parm_info.intValuesIndex + index; int[] int_value = { value }; if (myAsset.prAssetId < 0) { myAsset.buildClientSide(); } HoudiniHost.setParmIntValues(myAsset.prNodeId, int_value, values_index, 1); myAsset.buildClientSide(); }
public void syncPointsWithParm() { try { // Find the parm. HAPI_ParmInfo coords_parm_info = prParms.findParm("coords"); string point_list = HoudiniHost.getString(prParms.prParmStringHandles[coords_parm_info.stringValuesIndex]); if (point_list == null) { return; } // Clear all existing points. prPoints.Clear(); // Parse parm value for the points. string [] point_split = point_list.Split(new char [] { ' ' }); for (int i = 0; i < point_split.Length; ++i) { string vec_str = point_split[i]; string [] vec_split = vec_str.Split(new char [] { ',' }); if (vec_split.Length == 3) { Vector3 vec = new Vector3(); vec.x = (float)-System.Convert.ToDouble(vec_split[0]); vec.y = (float)System.Convert.ToDouble(vec_split[1]); vec.z = (float)System.Convert.ToDouble(vec_split[2]); prPoints.Add(vec); } } } catch {} }
public ParmType getParmType(string name) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); if (parm_info.isInt()) { return(ParmType.INT); } if (parm_info.isFloat()) { return(ParmType.FLOAT); } if (parm_info.isString()) { return(ParmType.STRING); } if (parm_info.isNonValue()) { return(ParmType.IMMUTABLE); } return(ParmType.INVALID); }
public void setChangedNodeParameterIntoHost(int id) { HAPI_ParmInfo parm = findParm(id); if (id >= myParmInputs.Length) { Array.Resize(ref myParmInputs, id + 1); } // Take care of old input node. if (myParmInputs[id].inputObject) { HoudiniHost.setParmNodeValue(prControl.prNodeId, parm.name, -1); if (myParmInputs[id].inputObject.GetComponent <HoudiniControl>()) { var houdini_control = myParmInputs[id].inputObject.GetComponent <HoudiniControl>(); houdini_control.prAsset.removeDownstreamAsset(myControl.prAsset); } else if (HoudiniHost.isNodeValid( myParmInputs[id].inputNodeId, myParmInputs[id].inputNodeUniqueId)) { HoudiniHost.deleteNode(myParmInputs[id].inputNodeId); } myParmInputs[id].inputObject = null; } if (!myParmInputs[id].newInputObject) { return; } myParmInputs[id].inputObject = myParmInputs[id].newInputObject; setNodeParameterIntoHost(id); }
public bool setNodeParameterIntoHost(int id) { HAPI_ParmInfo parm = findParm(id); var parm_input = myParmInputs[id]; if (!parm_input.inputObject) { return(false); } // Create new input node. GameObject input_object = parm_input.inputObject; HoudiniControl houdini_control = input_object.GetComponent <HoudiniControl>(); MeshFilter mesh_filter = input_object.GetComponent <MeshFilter>(); if (houdini_control && houdini_control.prAsset.gameObject.GetComponentInChildren <HoudiniGeoControl>()) { if (!houdini_control.prAsset.isAssetValid()) { houdini_control.prAsset.buildAll(); } HoudiniGeoControl geo_control = houdini_control.prAsset.gameObject.GetComponentInChildren <HoudiniGeoControl>(); parm_input.inputNodeId = geo_control.prNodeId; // Add ourselves to our input asset's downstream nodes so when it cooks we cook. houdini_control.prAsset.addDownstreamAsset(myControl.prAsset); } else if (houdini_control && input_object.GetComponent <HoudiniAssetCurve>()) { if (!houdini_control.prAsset.isAssetValid()) { houdini_control.prAsset.buildAll(); } parm_input.inputNodeId = houdini_control.prNodeId; // Add ourselves to our input asset's downstream nodes so when it cooks we cook. houdini_control.prAsset.addDownstreamAsset(myControl.prAsset); } else if (mesh_filter && mesh_filter.sharedMesh) { // We need to remove spaces in the input name string inputName = input_object.name.Replace(' ', '_'); parm_input.inputNodeId = HoudiniHost.createInputNode(inputName); Mesh mesh = mesh_filter.sharedMesh; HoudiniAssetUtility.setMesh( parm_input.inputNodeId, 0, parm_input.inputNodeId, ref mesh, null, null); // Set the asset transform from the source GameObject transform. HAPI_TransformEuler trans = HoudiniAssetUtility.getHapiTransform(input_object.transform.localToWorldMatrix); HAPI_NodeInfo input_node_info = HoudiniHost.getNodeInfo(parm_input.inputNodeId); HoudiniHost.setObjectTransform(input_node_info.parentId, ref trans); } else { return(false); } HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(parm_input.inputNodeId); parm_input.inputNodeUniqueId = node_info.uniqueHoudiniNodeId; // Assign node parm input. HoudiniHost.setParmNodeValue(prControl.prNodeId, parm.name, parm_input.inputNodeId); myParmInputs[id] = parm_input; return(true); }
public void getParameterValues() { if (prControl == null) { return; } if (prControl.prAsset == null) { return; } if (prControl.prAssetId < 0) { return; } if (myPostSerialization) { myValuesEqualToHoudini = areValuesEqualToHoudini(); } else { myValuesEqualToHoudini = true; } // Create undo info if it hasn't been created already if (myParmsUndoInfo == null) { myParmsUndoInfo = ScriptableObject.CreateInstance <HoudiniParmsUndoInfo>(); } // Get the node info again HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(prControl.prNodeId); prParmCount = node_info.parmCount; prParmIntValueCount = node_info.parmIntValueCount; prParmFloatValueCount = node_info.parmFloatValueCount; prParmStringValueCount = node_info.parmStringValueCount; prParmChoiceCount = node_info.parmChoiceCount; // Get all parameters. prParms = new HAPI_ParmInfo[prParmCount]; myParmInfoStrings = new HAPI_ParmInfoStrings[prParmCount]; if (myParmInputs == null) { myParmInputs = new HAPI_ParmInput[prParmCount]; } HoudiniAssetUtility.getArray1Id(prControl.prNodeId, HoudiniHost.getParameters, prParms, prParmCount); // Get parameter int values. prParmIntValues = new int[prParmIntValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmIntValues, prParmIntValues, prParmIntValueCount); myParmsUndoInfo.parmIntValues = new int[prParmIntValueCount]; Array.Copy(prParmIntValues, myParmsUndoInfo.parmIntValues, prParmIntValueCount); // Get parameter float values. prParmFloatValues = new float[prParmFloatValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmFloatValues, prParmFloatValues, prParmFloatValueCount); myParmsUndoInfo.parmFloatValues = new float[prParmFloatValueCount]; Array.Copy(prParmFloatValues, myParmsUndoInfo.parmFloatValues, prParmFloatValueCount); // Get parameter string (handle) values. prParmStringHandles = new int[prParmStringValueCount]; myParmStringValues = new string[prParmStringValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmStringValues, prParmStringHandles, prParmStringValueCount); // Get parameter choice lists. prParmChoiceLists = new HAPI_ParmChoiceInfo[prParmChoiceCount]; myParmChoiceInfoStrings = new HAPI_ParmChoiceInfoStrings[prParmChoiceCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmChoiceLists, prParmChoiceLists, prParmChoiceCount); cacheStringsFromHost(); // Go through parameters and set index map and multiparm map for undo info myParmsUndoInfo.parmNames.Clear(); myParmsUndoInfo.parmIndices.Clear(); foreach (HAPI_ParmInfo parm in prParms) { if (parm.isNode() && parm.id >= myParmInputs.Length) { // For input node params, make sure they have an entry // in myParmInputs for their data. Fixes bug 85804 setChangedNodeParameterIntoHost(parm.id); } // Need to check the index values are greater or equal to 0 // for now because there is a bug where some parameters are // being set to have an integer parameter type, a size of // zero, and an index value of -1 if (parm.isInt() && parm.intValuesIndex >= 0) { myParmsUndoInfo.parmIndices.Add(parm.intValuesIndex); } else if (parm.isFloat() && parm.floatValuesIndex >= 0) { myParmsUndoInfo.parmIndices.Add(parm.floatValuesIndex); } else if (parm.isString() && parm.stringValuesIndex >= 0) { myParmsUndoInfo.parmIndices.Add(parm.stringValuesIndex); } else { continue; } myParmsUndoInfo.parmNames.Add(parm.name); } }
HAPI_GetParmInfoFromName( ref HAPI_Session session, HAPI_NodeId node_id, string parm_name, out HAPI_ParmInfo parm_info);
public void appendMultiparmInstances( HAPI_ParmInfo multiparm, int num_instances ) { if ( prControl == null ) return; if ( prControl.prAsset == null ) return; int insert_position = multiparm.instanceCount + multiparm.instanceStartOffset; for ( int i = 0; i < num_instances; ++i ) HoudiniHost.insertMultiparmInstance( prControl.prNodeId, multiparm.id, // The multiparm list insert_position + i ); }
public void removeMultiparmInstances( HAPI_ParmInfo multiparm, int num_instances ) { if ( prControl == null ) return; if ( prControl.prAsset == null ) return; int first_removed_instance = multiparm.instanceCount - num_instances + multiparm.instanceStartOffset; for ( int i = 0; i < num_instances; ++i ) HoudiniHost.removeMultiparmInstance( prControl.prNodeId, multiparm.id, // The multiparm list first_removed_instance ); }
public static HAPI_ParmInfo getParmInfo( HAPI_NodeId node_id, HAPI_ParmId parm_id ) { #if ( UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || ( UNITY_METRO && UNITY_EDITOR ) ) HAPI_ParmInfo parm_info = new HAPI_ParmInfo(); HAPI_Result status_code = HAPI_GetParmInfo( ref mySession, node_id, parm_id, out parm_info ); processStatusCode( status_code ); return parm_info; #else throw new HoudiniErrorUnsupportedPlatform(); #endif }
public void removeMultiparmInstance(HAPI_ParmInfo parm) { myMultiparmInstancePos = parm; myToRemoveInstance = true; }
// This will retrieve the cached copy of the string public string[] getParmStrings(HAPI_ParmInfo parm) { return(myParmStrings[parm.id]); }
public void insertMultiparmInstance( HAPI_ParmInfo parm ) { myMultiparmInstancePos = parm; myToInsertInstance = true; }
// This will retrieve the cached copy of the string public string[] getParmStrings( HAPI_ParmInfo parm ) { return myParmStrings[ parm.id ]; }
private static extern HAPI_Result HAPI_GetParmInfoFromName( ref HAPI_Session session, HAPI_NodeId node_id, string parm_name, out HAPI_ParmInfo parm_info );
// Set into dictionary to later be set into the host public void setParmStrings( HAPI_ParmInfo parm, string[] strings ) { myParmStrings[ parm.id ] = strings; }
public int getParmSize(string name) { HAPI_ParmInfo parm_info = myAssetParms.findParm(name); return(parm_info.size); }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Public public void handlesOnSceneGUI() { if (myAssetOTL.prShowPinnedInstances) { drawPinnedInstances(); } // On mouse up the drag operation is completed. if (Event.current.type == EventType.MouseUp) { myOpInProgress = false; } string currentGlobalManipTool = Tools.current.ToString(); if (currentGlobalManipTool == "Rotate") { myManipMode = XformManipMode.Rotate; } else if (currentGlobalManipTool == "Move") { myManipMode = XformManipMode.Translate; } else if (currentGlobalManipTool == "Scale") { myManipMode = XformManipMode.Scale; } if (myAssetOTL == null) { return; } int node_id = myAssetOTL.prNodeId; HAPI_HandleInfo[] handleInfos = myAssetOTL.prHandleInfos; if (handleInfos == null) { return; } // Detect changes and build asset only when changed. bool changed = false; for (int ii = 0; ii < handleInfos.Length; ++ii) { HAPI_HandleInfo handleInfo = handleInfos[ii]; if (handleInfo.typeName == "xform") { float tx = 0, ty = 0, tz = 0; float rx = 0, ry = 0, rz = 0; float sx = 1, sy = 1, sz = 1; HAPI_RSTOrder rstOrder = HAPI_RSTOrder.HAPI_SRT; HAPI_XYZOrder xyzOrder = HAPI_XYZOrder.HAPI_XYZ; HAPI_HandleBindingInfo[] bindingInfos = myAssetOTL.prHandleBindingInfos[ii]; int[] parm_int_values = myAssetOTL.prParms.prParmIntValues; float[] parm_float_values = myAssetOTL.prParms.prParmFloatValues; if (parm_int_values == null || parm_float_values == null) { Debug.LogError("No parm int/float values yet handles exist?"); continue; } int translate_parm_id = -1; int rotate_parm_id = -1; int scale_parm_id = -1; int rst_order_parm_id = -1; int xyz_order_parm_id = -1; foreach (HAPI_HandleBindingInfo bindingInfo in bindingInfos) { string parm_name = bindingInfo.handleParmName; if (parm_name == "tx") { translate_parm_id = bindingInfo.assetParmId; } else if (parm_name == "rx") { rotate_parm_id = bindingInfo.assetParmId; } else if (parm_name == "sx") { scale_parm_id = bindingInfo.assetParmId; } else if (parm_name == "trs_order") { rst_order_parm_id = bindingInfo.assetParmId; } else if (parm_name == "xyz_order") { xyz_order_parm_id = bindingInfo.assetParmId; } } if (translate_parm_id >= 0) { HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(translate_parm_id); tx = parm_float_values[parm_info.floatValuesIndex + 0]; ty = parm_float_values[parm_info.floatValuesIndex + 1]; tz = parm_float_values[parm_info.floatValuesIndex + 2]; } if (rotate_parm_id >= 0) { HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rotate_parm_id); rx = parm_float_values[parm_info.floatValuesIndex + 0]; ry = parm_float_values[parm_info.floatValuesIndex + 1]; rz = parm_float_values[parm_info.floatValuesIndex + 2]; } if (scale_parm_id >= 0) { HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(scale_parm_id); sx = parm_float_values[parm_info.floatValuesIndex + 0]; sy = parm_float_values[parm_info.floatValuesIndex + 1]; sz = parm_float_values[parm_info.floatValuesIndex + 2]; } if (rst_order_parm_id >= 0) { HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rst_order_parm_id); rstOrder = (HAPI_RSTOrder)parm_int_values[parm_info.intValuesIndex]; } if (xyz_order_parm_id >= 0) { HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(xyz_order_parm_id); xyzOrder = (HAPI_XYZOrder)parm_int_values[parm_info.intValuesIndex]; } HAPI_TransformEuler xform = new HAPI_TransformEuler(true); // This bit is a little tricky. We will eventually call Handle.PositionHandle // or Handle.RotationHandle to display the translation and rotation handles. // These function take a translation parameter and a rotation parameter in // order to display the handle in its proper location and orientation. // These functions have an assumed order that it will put the rotation // and translation back together. Depending whether the order of translation // and roation matches that of the rstOrder setting, we may, or may not // need to convert the translation parameter for use with the handle. if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT) { xform.position[0] = tx; xform.position[1] = ty; xform.position[2] = tz; xform.rotationEuler[0] = rx; xform.rotationEuler[1] = ry; xform.rotationEuler[2] = rz; xform.scale[0] = 1; xform.scale[1] = 1; xform.scale[2] = 1; xform.rotationOrder = xyzOrder; xform.rstOrder = rstOrder; } else { xform.position[0] = 0; xform.position[1] = 0; xform.position[2] = 0; xform.rotationEuler[0] = rx; xform.rotationEuler[1] = ry; xform.rotationEuler[2] = rz; xform.scale[0] = 1; xform.scale[1] = 1; xform.scale[2] = 1; xform.rotationOrder = xyzOrder; xform.rstOrder = rstOrder; } xform = HoudiniHost.convertTransform(xform, HAPI_RSTOrder.HAPI_SRT, HAPI_XYZOrder.HAPI_ZXY); // Axis and Rotation conversions: // Note that Houdini's X axis points in the opposite direction that Unity's does. Also, Houdini's // rotation is right handed, whereas Unity is left handed. To account for this, we need to invert // the x coordinate of the translation, and do the same for the rotations (except for the x rotation, // which doesn't need to be flipped because the change in handedness AND direction of the left x axis // causes a double negative - yeah, I know). xform.position[0] = -xform.position[0]; xform.rotationEuler[1] = -xform.rotationEuler[1]; xform.rotationEuler[2] = -xform.rotationEuler[2]; tx = -tx; Handles.matrix = myAssetOTL.transform.localToWorldMatrix; Vector3 position; if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT) { position = new Vector3(xform.position[0], xform.position[1], xform.position[2]); } else { position = new Vector3(tx, ty, tz); } Quaternion rotation = Quaternion.Euler( xform.rotationEuler[0], xform.rotationEuler[1], xform.rotationEuler[2]); Vector3 scale = new Vector3(sx, sy, sz); if (myManipMode == XformManipMode.Translate) { if (translate_parm_id < 0) { continue; } HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(translate_parm_id); if (parm_info.invisible) { continue; } GUIStyle style = new GUIStyle(EditorStyles.textField); style.contentOffset = new Vector2(1.4f, 1.4f); string handle_name = handleInfo.name; if (parm_info.disabled) { handle_name = handle_name + " (disabled)"; } GUIContent content = new GUIContent(handle_name); content.tooltip = handle_name; Handles.Label(position, content, style); if (parm_info.disabled) { Handles.lighting = false; Handles.PositionHandle(position, rotation); Handles.lighting = true; continue; } Vector3 new_position = Handles.PositionHandle(position, rotation); if (new_position != position) { changed = true; if (!myOpInProgress) { Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name); myOpInProgress = true; } if (rstOrder == HAPI_RSTOrder.HAPI_TSR || rstOrder == HAPI_RSTOrder.HAPI_STR || rstOrder == HAPI_RSTOrder.HAPI_SRT) { xform.position[0] = new_position[0]; xform.position[1] = new_position[1]; xform.position[2] = new_position[2]; xform = HoudiniHost.convertTransform(xform, rstOrder, xyzOrder); new_position.x = xform.position[0]; new_position.y = xform.position[1]; new_position.z = xform.position[2]; } // the - in the x coordinate is to convert back to "Houdini" coordinates parm_float_values[parm_info.floatValuesIndex + 0] = -new_position.x; parm_float_values[parm_info.floatValuesIndex + 1] = new_position.y; parm_float_values[parm_info.floatValuesIndex + 2] = new_position.z; float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE]; for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp) { temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp]; } HoudiniHost.setParmFloatValues(node_id, temp_float_values, parm_info.floatValuesIndex, parm_info.size); myAsset.savePreset(); } // if changed } else if (myManipMode == XformManipMode.Rotate) { if (rotate_parm_id < 0) { continue; } HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(rotate_parm_id); if (parm_info.invisible) { continue; } GUIStyle style = new GUIStyle(EditorStyles.textField); style.contentOffset = new Vector2(1.4f, 1.4f); string handle_name = handleInfo.name; if (parm_info.disabled) { handle_name = handle_name + " (disabled)"; } GUIContent content = new GUIContent(handle_name); content.tooltip = handle_name; Handles.Label(position, content, style); if (parm_info.disabled) { Handles.lighting = false; Handles.RotationHandle(rotation, position); Handles.lighting = true; continue; } Quaternion new_rotation = Handles.RotationHandle(rotation, position); if (new_rotation != rotation) { changed = true; if (!myOpInProgress) { Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name); myOpInProgress = true; } Vector3 newRot = new_rotation.eulerAngles; xform.position[0] = 0; xform.position[1] = 0; xform.position[2] = 0; xform.rotationEuler[0] = newRot.x; xform.rotationEuler[1] = newRot.y; xform.rotationEuler[2] = newRot.z; xform.scale[0] = 1; xform.scale[1] = 1; xform.scale[2] = 1; xform.rotationOrder = HAPI_XYZOrder.HAPI_ZXY; xform.rstOrder = HAPI_RSTOrder.HAPI_SRT; xform = HoudiniHost.convertTransform(xform, rstOrder, xyzOrder); parm_float_values[parm_info.floatValuesIndex + 0] = xform.rotationEuler[0]; // the - in the y & z coordinate is to convert back to "Houdini" coordinates parm_float_values[parm_info.floatValuesIndex + 1] = -xform.rotationEuler[1]; parm_float_values[parm_info.floatValuesIndex + 2] = -xform.rotationEuler[2]; float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE]; for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp) { temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp]; } HoudiniHost.setParmFloatValues( node_id, temp_float_values, parm_info.floatValuesIndex, parm_info.size); myAsset.savePreset(); } // if changed } else if (myManipMode == XformManipMode.Scale) { if (scale_parm_id < 0) { continue; } HAPI_ParmInfo parm_info = myAssetOTL.prParms.findParm(scale_parm_id); if (parm_info.invisible) { continue; } GUIStyle style = new GUIStyle(EditorStyles.textField); style.contentOffset = new Vector2(1.4f, 1.4f); string handle_name = handleInfo.name; if (parm_info.disabled) { handle_name = handle_name + " (disabled)"; } GUIContent content = new GUIContent(handle_name); content.tooltip = handle_name; Handles.Label(position, content, style); if (parm_info.disabled) { Handles.lighting = false; Handles.ScaleHandle(scale, position, rotation, 1.0f); Handles.lighting = true; continue; } Vector3 new_scale = Handles.ScaleHandle(scale, position, rotation, 1.0f); if (new_scale != scale) { changed = true; if (!myOpInProgress) { Undo.RecordObject(myAssetOTL.prParms.prParmsUndoInfo, handleInfo.name); myOpInProgress = true; } parm_float_values[parm_info.floatValuesIndex + 0] = new_scale.x; parm_float_values[parm_info.floatValuesIndex + 1] = new_scale.y; parm_float_values[parm_info.floatValuesIndex + 2] = new_scale.z; float[] temp_float_values = new float[HoudiniConstants.HAPI_POSITION_VECTOR_SIZE]; for (int pp = 0; pp < HoudiniConstants.HAPI_POSITION_VECTOR_SIZE; ++pp) { temp_float_values[pp] = parm_float_values[parm_info.floatValuesIndex + pp]; } HoudiniHost.setParmFloatValues( node_id, temp_float_values, parm_info.floatValuesIndex, parm_info.size); myAsset.savePreset(); } // if changed } // if myManipMode } // if typeName } // for each handle if (changed) { myAssetOTL.buildClientSide(); } }
public void getParameterValues() { if (prControl == null) { return; } if (prControl.prAsset == null) { return; } if (prControl.prAssetId < 0) { return; } if (myPostSerialization) { myValuesEqualToHoudini = areValuesEqualToHoudini(); } else { myValuesEqualToHoudini = true; } // Create undo info if it hasn't been created already if (myParmsUndoInfo == null) { myParmsUndoInfo = ScriptableObject.CreateInstance <HoudiniParmsUndoInfo>(); } // Get the node info again HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo(prControl.prNodeId); prParmCount = node_info.parmCount; prParmIntValueCount = node_info.parmIntValueCount; prParmFloatValueCount = node_info.parmFloatValueCount; prParmStringValueCount = node_info.parmStringValueCount; prParmChoiceCount = node_info.parmChoiceCount; // Get all parameters. prParms = new HAPI_ParmInfo[prParmCount]; HoudiniAssetUtility.getArray1Id(prControl.prNodeId, HoudiniHost.getParameters, prParms, prParmCount); // Get parameter int values. prParmIntValues = new int[prParmIntValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmIntValues, prParmIntValues, prParmIntValueCount); myParmsUndoInfo.parmIntValues = new int[prParmIntValueCount]; Array.Copy(prParmIntValues, myParmsUndoInfo.parmIntValues, prParmIntValueCount); // Get parameter float values. prParmFloatValues = new float[prParmFloatValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmFloatValues, prParmFloatValues, prParmFloatValueCount); myParmsUndoInfo.parmFloatValues = new float[prParmFloatValueCount]; Array.Copy(prParmFloatValues, myParmsUndoInfo.parmFloatValues, prParmFloatValueCount); // Get parameter string (handle) values. prParmStringValues = new int[prParmStringValueCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmStringValues, prParmStringValues, prParmStringValueCount); // Get parameter choice lists. prParmChoiceLists = new HAPI_ParmChoiceInfo[prParmChoiceCount]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmChoiceLists, prParmChoiceLists, prParmChoiceCount); // Build the map of parm id -> parm for (int i = 0; i < prParms.Length; ++i) { myParmMap[prParms[i].id] = prParms[i]; } cacheStringsFromHost(); // Go through parameters and set index map and multiparm map for undo info myParmsUndoInfo.parmNames.Clear(); myParmsUndoInfo.parmIndices.Clear(); foreach (HAPI_ParmInfo parm in prParms) { // Need to check the index values are greater or equal to 0 // for now because there is a bug where some parameters are // being set to have an integer parameter type, a size of // zero, and an index value of -1 if (parm.isInt() && parm.intValuesIndex >= 0) { myParmsUndoInfo.parmIndices.Add(parm.intValuesIndex); } else if (parm.isFloat() && parm.floatValuesIndex >= 0) { myParmsUndoInfo.parmIndices.Add(parm.floatValuesIndex); } else if (parm.isString() && parm.stringValuesIndex >= 0) { myParmsUndoInfo.parmIndices.Add(parm.stringValuesIndex); } else { continue; } myParmsUndoInfo.parmNames.Add(parm.name); } #if UNITY_EDITOR // Set which parameter values have been overridden (only needed for a prefab instance) if (prControl && prControl.isPrefabInstance() && gameObject.GetComponent <HoudiniAsset>() != null) { HoudiniAsset prefab_asset = prControl.prAsset.getParentPrefabAsset(); if (prefab_asset && prefab_asset.prParms != null && prefab_asset.prParms.prParms != null && !prefab_asset.isApplyingChangesToPrefab()) { // loop through parameter values and determine which ones have been // overridden (ie. changed from corresponding parameter value on prefab) for (int i = 0; i < prParms.Length; ++i) { myOverriddenParmsMap[prParms[i].id] = !isParmSameInPrefab(prParms[i].id, prefab_asset.prParms); } } // This tells Unity that parameter values have been overridden for this prefab instance PrefabUtility.RecordPrefabInstancePropertyModifications(this); } #endif // UNITY_EDITOR }
HAPI_GetParmInfo( ref HAPI_Session session, HAPI_NodeId node_id, HAPI_ParmId parm_id, out HAPI_ParmInfo parm_info);
HAPI_GetParmInfo( ref HAPI_Session session, HAPI_NodeId node_id, HAPI_ParmId parm_id, out HAPI_ParmInfo parm_info );
public void insertMultiparmInstance(HAPI_ParmInfo parm) { myMultiparmInstancePos = parm; myToInsertInstance = true; }
HAPI_GetParmInfoFromName( ref HAPI_Session session, HAPI_NodeId node_id, string parm_name, out HAPI_ParmInfo parm_info );
// Set into dictionary to later be set into the host public void setParmStrings(HAPI_ParmInfo parm, string[] strings) { myParmStrings[parm.id] = strings; }
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); }
// Checks if the parameter with the given id parm_id represents the same parameter // with the same value in this set of parameters and another set of parameters parmsB. public bool isParmSameInPrefab(int parm_id, HoudiniParms parmsB) { HAPI_ParmInfo parm_infoA = findParm(parm_id); HAPI_ParmInfo parm_infoB = parmsB.findParm(parm_id); if (parm_infoA.GetType() != parm_infoB.GetType() || parm_infoA.size != parm_infoB.size || parm_infoA.name != parm_infoB.name || parm_infoA.label != parm_infoB.label) { Debug.LogError("Parameter structure is different from prefab"); return(false); } // only need to check type and size of one because already checked that // parameter infos have type and size if (parm_infoA.isFloat()) { for (int ii = 0; ii < parm_infoA.size; ii++) { float valueA = prParmFloatValues[parm_infoA.floatValuesIndex + ii]; float valueB = parmsB.prParmFloatValues[parm_infoB.floatValuesIndex + ii]; if (valueA != valueB) { return(false); } } } else if (parm_infoB.isInt()) { for (int ii = 0; ii < parm_infoA.size; ii++) { int valueA = prParmIntValues[parm_infoA.intValuesIndex + ii]; int valueB = parmsB.prParmIntValues[parm_infoB.intValuesIndex + ii]; if (valueA != valueB) { return(false); } } } else if (parm_infoB.isString()) { string[] valuesA = getParmStrings(parm_infoA); string[] valuesB = parmsB.getParmStrings(parm_infoB); if (valuesA.Length != valuesB.Length) { return(false); } for (int ii = 0; ii < valuesA.Length; ii++) { if (valuesA[ii] != valuesB[ii]) { return(false); } } } return(true); }
public void removeMultiparmInstance( HAPI_ParmInfo parm ) { myMultiparmInstancePos = parm; myToRemoveInstance = true; }
private static extern HAPI_Result HAPI_GetParmInfo( ref HAPI_Session session, HAPI_NodeId node_id, HAPI_ParmId parm_id, out HAPI_ParmInfo parm_info );
public void getParameterValues() { if ( prControl == null ) return; if ( prControl.prAsset == null ) return; if ( prControl.prAssetId < 0 ) return; if ( myPostSerialization ) myValuesEqualToHoudini = areValuesEqualToHoudini(); else myValuesEqualToHoudini = true; // Create undo info if it hasn't been created already if ( myParmsUndoInfo == null ) myParmsUndoInfo = ScriptableObject.CreateInstance< HoudiniParmsUndoInfo >(); // Get the node info again HAPI_NodeInfo node_info = HoudiniHost.getNodeInfo( prControl.prNodeId ); prParmCount = node_info.parmCount; prParmIntValueCount = node_info.parmIntValueCount; prParmFloatValueCount = node_info.parmFloatValueCount; prParmStringValueCount = node_info.parmStringValueCount; prParmChoiceCount = node_info.parmChoiceCount; // Get all parameters. prParms = new HAPI_ParmInfo[ prParmCount ]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParameters, prParms, prParmCount ); // Get parameter int values. prParmIntValues = new int[ prParmIntValueCount ]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmIntValues, prParmIntValues, prParmIntValueCount ); myParmsUndoInfo.parmIntValues = new int[ prParmIntValueCount ]; Array.Copy( prParmIntValues, myParmsUndoInfo.parmIntValues, prParmIntValueCount ); // Get parameter float values. prParmFloatValues = new float[ prParmFloatValueCount ]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmFloatValues, prParmFloatValues, prParmFloatValueCount ); myParmsUndoInfo.parmFloatValues = new float[ prParmFloatValueCount ]; Array.Copy( prParmFloatValues, myParmsUndoInfo.parmFloatValues, prParmFloatValueCount ); // Get parameter string (handle) values. prParmStringValues = new int[ prParmStringValueCount ]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmStringValues, prParmStringValues, prParmStringValueCount ); // Get parameter choice lists. prParmChoiceLists = new HAPI_ParmChoiceInfo[ prParmChoiceCount ]; HoudiniAssetUtility.getArray1Id( prControl.prNodeId, HoudiniHost.getParmChoiceLists, prParmChoiceLists, prParmChoiceCount ); // Build the map of parm id -> parm for ( int i = 0; i < prParms.Length; ++i ) myParmMap[ prParms[ i ].id ] = prParms[ i ]; cacheStringsFromHost(); // Go through parameters and set index map and multiparm map for undo info myParmsUndoInfo.parmNames.Clear(); myParmsUndoInfo.parmIndices.Clear(); foreach ( HAPI_ParmInfo parm in prParms ) { // Need to check the index values are greater or equal to 0 // for now because there is a bug where some parameters are // being set to have an integer parameter type, a size of // zero, and an index value of -1 if ( parm.isInt() && parm.intValuesIndex >= 0 ) myParmsUndoInfo.parmIndices.Add( parm.intValuesIndex ); else if ( parm.isFloat() && parm.floatValuesIndex >= 0 ) myParmsUndoInfo.parmIndices.Add( parm.floatValuesIndex ); else if ( parm.isString() && parm.stringValuesIndex >= 0 ) myParmsUndoInfo.parmIndices.Add( parm.stringValuesIndex ); else continue; myParmsUndoInfo.parmNames.Add( parm.name ); } #if UNITY_EDITOR // Set which parameter values have been overridden (only needed for a prefab instance) if ( prControl && prControl.isPrefabInstance() && gameObject.GetComponent< HoudiniAsset >() != null ) { HoudiniAsset prefab_asset = prControl.prAsset.getParentPrefabAsset(); if ( prefab_asset && prefab_asset.prParms != null && prefab_asset.prParms.prParms != null && !prefab_asset.isApplyingChangesToPrefab() ) { // loop through parameter values and determine which ones have been // overridden (ie. changed from corresponding parameter value on prefab) for ( int i = 0; i < prParms.Length; ++i ) { myOverriddenParmsMap[ prParms[ i ].id ] = !isParmSameInPrefab( prParms[ i ].id, prefab_asset.prParms ); } } // This tells Unity that parameter values have been overridden for this prefab instance PrefabUtility.RecordPrefabInstancePropertyModifications( this ); } #endif // UNITY_EDITOR }