// 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
}
